From 7e65590a55ba575d0086bdfc25addaf1051d799b Mon Sep 17 00:00:00 2001
From: Justin Clark-Casey (justincc)
Date: Sat, 11 Sep 2010 01:13:08 +0100
Subject: Update Prebuild.exe with Prebuild r323 + an existing OpenSim specific
nant hack to correctly clean up chosen OpenSim exes and dlls in bin/ on a
"nant clean"
Source code is included for reference. This can go away again once Prebuild is updated with a more general mechanism for cleaning up files.
The Prebuild source code here can be built with nant, or regnerated for other tools using the prebuild at {root}/bin/Prebuild.exe
---
Prebuild/src/Core/Targets/.svn/all-wcprops | 101 ++
Prebuild/src/Core/Targets/.svn/dir-prop-base | 5 +
Prebuild/src/Core/Targets/.svn/entries | 572 +++++++++++
.../Targets/.svn/prop-base/DebugTarget.cs.svn-base | 9 +
.../.svn/prop-base/MakefileTarget.cs.svn-base | 9 +
.../.svn/prop-base/MonoDevelopTarget.cs.svn-base | 9 +
.../Targets/.svn/prop-base/NAntTarget.cs.svn-base | 9 +
.../.svn/prop-base/SharpDevelopTarget.cs.svn-base | 9 +
.../.svn/prop-base/VS2002Target.cs.svn-base | 9 +
.../.svn/prop-base/VS2003Target.cs.svn-base | 9 +
.../.svn/prop-base/VS2005Target.cs.svn-base | 9 +
.../Targets/.svn/prop-base/XcodeTarget.cs.svn-base | 9 +
.../.svn/text-base/AutotoolsTarget.cs.svn-base | 1070 ++++++++++++++++++++
.../Targets/.svn/text-base/DebugTarget.cs.svn-base | 102 ++
.../.svn/text-base/MakefileTarget.cs.svn-base | 469 +++++++++
.../.svn/text-base/MonoDevelopTarget.cs.svn-base | 515 ++++++++++
.../Targets/.svn/text-base/NAntTarget.cs.svn-base | 776 ++++++++++++++
.../.svn/text-base/SharpDevelop2Target.cs.svn-base | 82 ++
.../.svn/text-base/SharpDevelopTarget.cs.svn-base | 425 ++++++++
.../Targets/.svn/text-base/ToolInfo.cs.svn-base | 197 ++++
.../.svn/text-base/VS2002Target.cs.svn-base | 87 ++
.../.svn/text-base/VS2003Target.cs.svn-base | 593 +++++++++++
.../.svn/text-base/VS2005Target.cs.svn-base | 147 +++
.../.svn/text-base/VS2008Target.cs.svn-base | 127 +++
.../.svn/text-base/VS2010Target.cs.svn-base | 138 +++
.../.svn/text-base/VSGenericTarget.cs.svn-base | 922 +++++++++++++++++
.../Targets/.svn/text-base/VSVersion.cs.svn-base | 54 +
.../Targets/.svn/text-base/XcodeTarget.cs.svn-base | 594 +++++++++++
28 files changed, 7057 insertions(+)
create mode 100644 Prebuild/src/Core/Targets/.svn/all-wcprops
create mode 100644 Prebuild/src/Core/Targets/.svn/dir-prop-base
create mode 100644 Prebuild/src/Core/Targets/.svn/entries
create mode 100644 Prebuild/src/Core/Targets/.svn/prop-base/DebugTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/prop-base/MakefileTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/prop-base/MonoDevelopTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/prop-base/NAntTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/prop-base/SharpDevelopTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/prop-base/VS2002Target.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/prop-base/VS2003Target.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/prop-base/VS2005Target.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/prop-base/XcodeTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/AutotoolsTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/DebugTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/MakefileTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/MonoDevelopTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/NAntTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/SharpDevelop2Target.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/SharpDevelopTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/ToolInfo.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/VS2002Target.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/VS2003Target.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/VS2005Target.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/VS2008Target.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/VS2010Target.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/VSGenericTarget.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/VSVersion.cs.svn-base
create mode 100644 Prebuild/src/Core/Targets/.svn/text-base/XcodeTarget.cs.svn-base
(limited to 'Prebuild/src/Core/Targets/.svn')
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; }
+ }
+
+ }
+
+
+ ///
+ ///
+ ///
+ [Target("autotools")]
+ public class AutotoolsTarget : ITarget
+ {
+ #region Fields
+
+ Kernel m_Kernel;
+ XmlDocument autotoolsDoc;
+ XmlUrlResolver xr;
+ System.Security.Policy.Evidence e;
+ readonly Dictionary assemblyPathToPackage = new Dictionary();
+ readonly Dictionary assemblyFullNameToPath = new Dictionary();
+ readonly Dictionary packagesHash = new Dictionary();
+ readonly List packages = new List();
+
+ #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 GetAssembliesWithLibInfo(string line, string file)
+ {
+ List references = new List();
+ List libdirs = new List();
+ List retval = new List();
+ 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 GetAssembliesWithoutLibInfo(string line, string file)
+ {
+ List references = new List();
+ 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 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 list = new List();
+
+ 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 scanDirs = new List();
+ 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;
+ }
+
+ ///
+ /// Gets the XML doc file.
+ ///
+ /// The project.
+ /// The conf.
+ ///
+ 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;
+ }
+
+ ///
+ /// Normalizes the path.
+ ///
+ /// The path.
+ ///
+ 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
+ compiledFiles = new List(),
+ contentFiles = new List(),
+ embeddedFiles = new List(),
+
+ binaryLibs = new List(),
+ pkgLibs = new List(),
+ systemLibs = new List(),
+ runtimeLibs = new List(),
+
+ extraDistFiles = new List(),
+ localCopyTargets = new List();
+
+ // 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
+
+ ///
+ /// Writes the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Cleans the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ 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
+{
+ ///
+ ///
+ ///
+ [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 = "";
+ }
+ 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;
+ }
+
+ ///
+ /// Gets the XML doc file.
+ ///
+ /// The project.
+ /// The conf.
+ ///
+ 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,
+ project.RootNamespace
+ );
+
+ int count = 0;
+
+ ss.WriteLine(" ", solution.ActiveConfig);
+
+ foreach(ConfigurationNode conf in project.Configurations)
+ {
+ ss.WriteLine(" ", conf.Name);
+ ss.Write(" ");
+
+ ss.Write(" ");
+
+ ss.Write(" ");
+
+ ss.Write(" ");
+ ss.WriteLine(" ");
+
+ count++;
+ }
+ ss.WriteLine(" ");
+
+ ss.Write(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+ 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(" ",
+ filePath, buildAction, dependson, resource_id, copyToOutput);
+ }
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+ foreach(ReferenceNode refr in project.References)
+ {
+ ss.WriteLine(" {0}", BuildReference(solution, refr));
+ }
+ ss.WriteLine(" ");
+
+
+ ss.WriteLine("");
+ }
+
+ 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("", solution.Name);
+
+ count = 0;
+ foreach(ConfigurationNode conf in solution.Configurations)
+ {
+ if(count == 0)
+ {
+ ss.WriteLine(" ", conf.Name);
+ }
+
+ ss.WriteLine(" ", conf.Name);
+ foreach(ProjectNode project in solution.Projects)
+ {
+ ss.WriteLine(" ", project.Name, conf.Name);
+ }
+ ss.WriteLine(" ");
+
+ count++;
+ }
+ ss.WriteLine(" ");
+
+ count = 0;
+
+ foreach(ProjectNode project in solution.Projects)
+ {
+ if(count == 0)
+ ss.WriteLine(" ", project.Name);
+
+ ss.WriteLine(" ", project.Name);
+ count++;
+ }
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+ foreach(ProjectNode project in solution.Projects)
+ {
+ string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+ ss.WriteLine(" ",
+ Helper.MakeFilePath(path, project.Name, "mdp"));
+ }
+ ss.WriteLine(" ");
+
+ ss.WriteLine("");
+ }
+
+ 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
+
+ ///
+ /// Writes the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Cleans the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ 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
+{
+ ///
+ ///
+ ///
+ [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;
+ }
+
+ ///
+ /// Gets the XML doc file.
+ ///
+ /// The project.
+ /// The conf.
+ ///
+ 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("");
+ ss.WriteLine("", project.Name);
+ ss.WriteLine(" ", "build");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ foreach (ReferenceNode refr in project.References)
+ {
+ if (refr.LocalCopy)
+ {
+ ss.WriteLine(" ", '/'));
+ }
+ }
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ if (project.ConfigFile != null && project.ConfigFile.Length!=0)
+ {
+ ss.Write(" ");
+ }
+
+ // Add the content files to just be copied
+ ss.WriteLine(" {0}", "");
+ ss.WriteLine(" {0}", "");
+
+ 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}", "");
+ }
+
+ ss.WriteLine(" {0}", "");
+ ss.WriteLine(" {0}", "");
+
+ ss.Write(" ");
+ ss.WriteLine(" ", project.RootNamespace);
+ foreach (string file in project.Files)
+ {
+ switch (project.Files.GetBuildAction(file))
+ {
+ case BuildAction.EmbeddedResource:
+ ss.WriteLine(" {0}", "");
+ break;
+ default:
+ if (project.Files.GetSubType(file) != SubType.Code && project.Files.GetSubType(file) != SubType.Settings)
+ {
+ ss.WriteLine(" ", file.Substring(0, file.LastIndexOf('.')) + ".resx");
+ }
+ break;
+ }
+ }
+ //if (project.Files.GetSubType(file).ToString() != "Code")
+ //{
+ // ps.WriteLine(" ", file.Substring(0, file.LastIndexOf('.')) + ".resx");
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ foreach (string file in project.Files)
+ {
+ switch (project.Files.GetBuildAction(file))
+ {
+ case BuildAction.Compile:
+ ss.WriteLine(" ");
+ break;
+ default:
+ break;
+ }
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ foreach(ReferencePathNode refPath in project.ReferencePaths)
+ {
+ ss.WriteLine(" ");
+ }
+ ss.WriteLine(" ");
+ 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 (" ");
+ }
+ else
+ {
+ ss.WriteLine (" ");
+ }
+ }
+ else
+ {
+ ss.WriteLine (" ");
+ }
+ }
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+
+ foreach (ConfigurationNode conf in project.Configurations)
+ {
+ if (!String.IsNullOrEmpty(conf.Options.OutputPath))
+ {
+ string targetDir = Helper.NormalizePath(conf.Options.OutputPath, '/');
+
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ break;
+ }
+ }
+
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+ if (hasDoc)
+ {
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.Write(" ");
+ }
+ else
+ {
+ ss.WriteLine(".exe\" />");
+ }
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ // foreach(ReferenceNode refr in project.References)
+ // {
+ // string path = Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReferencePath(solution, refr)), '/');
+ // if (path != "")
+ // {
+ // ss.WriteLine(" ", path);
+ // }
+ // }
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine("");
+ }
+ 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("");
+ ss.WriteLine("", solution.Name);
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ //ss.WriteLine(" ");
+ //ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+
+ // Use the active configuration, which is the first configuration name in the prebuild file.
+ Dictionary emittedConfigurations = new Dictionary();
+
+ ss.WriteLine(" ", 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(" ", conf.Name, conf.Platform);
+ ss.WriteLine(" ");
+ ss.WriteLine();
+ }
+
+ // Write out the target for the configuration.
+ ss.WriteLine(" ", conf.Name, conf.Platform);
+ ss.WriteLine(" ", conf.Name);
+ ss.WriteLine(" ", conf.Options["DebugInformation"].ToString().ToLower());
+ ss.WriteLine("\t\t ", conf.Platform);
+ ss.WriteLine(" ");
+ ss.WriteLine();
+ }
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ 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("", (item).FullName);
+ while (sr.Peek() != -1)
+ {
+ ss.WriteLine(sr.ReadLine());
+ }
+ ss.WriteLine();
+ }
+ }
+ }
+ }
+ }
+ }
+ catch { }
+ // ss.WriteLine(" ");
+ // ss.WriteLine(" ");
+ // ss.WriteLine(" ", solution.Name, solution.Version);
+ // ss.WriteLine(" ");
+
+ // ss.WriteLine(" ");
+ // // ss.WriteLine(" ");
+ // ss.WriteLine(" ");
+ // ss.WriteLine(" ");
+ // ss.WriteLine(" ");
+ // ss.WriteLine(" ");
+ ss.WriteLine();
+
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ //ss.WriteLine(" ");
+ if (solution.Cleanup != null && solution.Cleanup.CleanFiles.Count > 0)
+ {
+ foreach (CleanFilesNode cleanFile in solution.Cleanup.CleanFiles)
+ {
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ", cleanFile.Pattern);
+ ss.WriteLine(" ", cleanFile.Pattern);
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ }
+ }
+ ss.WriteLine(" ");
+ foreach (ProjectNode project in solution.Projects)
+ {
+ string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+ ss.Write(" ");
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+
+ foreach (ProjectNode project in solution.ProjectsTableOrder)
+ {
+ string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+ ss.Write(" ");
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine();
+ ss.WriteLine(" ");
+ ss.WriteLine();
+ //ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ foreach (ProjectNode project in solution.Projects)
+ {
+ string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+ ss.Write(" ");
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine();
+ ss.WriteLine("");
+ }
+
+ 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
+
+ ///
+ /// Writes the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Cleans the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ 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
+{
+ ///
+ ///
+ ///
+ [Target("sharpdev2")]
+ public class SharpDevelop2Target : VS2005Target
+ {
+ #region Properties
+ public override string VersionName
+ {
+ get
+ {
+ return "SharpDevelop2";
+ }
+ }
+ #endregion
+
+ #region Public Methods
+
+ ///
+ /// Writes the specified kern.
+ ///
+ /// The kern.
+ public override void Write(Kernel kern)
+ {
+ base.Write(kern);
+ }
+
+ ///
+ /// Cleans the specified kern.
+ ///
+ /// The kern.
+ public override void Clean(Kernel kern)
+ {
+ base.Clean(kern);
+ }
+
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ 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
+{
+ ///
+ ///
+ ///
+ [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 = "";
+ }
+ 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;
+ }
+
+ ///
+ /// Gets the XML doc file.
+ ///
+ /// The project.
+ /// The conf.
+ ///
+ 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,
+ project.RootNamespace
+ );
+
+ ss.WriteLine(" ");
+ 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(" ", filePath, buildAction);
+ }
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+ foreach(ReferenceNode refr in project.References)
+ {
+ ss.WriteLine(" {0}", BuildReference(solution, refr));
+ }
+ ss.WriteLine(" ");
+
+ ss.Write(" ");
+
+ int count = 0;
+
+ ss.WriteLine(" ", solution.ActiveConfig);
+
+ foreach(ConfigurationNode conf in project.Configurations)
+ {
+ ss.Write(" ");
+ ss.Write(" ");
+
+ ss.Write(" ");
+
+ ss.Write(" ");
+ ss.WriteLine(" ");
+
+ count++;
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine("");
+ }
+
+ 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("", solution.Name);
+
+ int count = 0;
+ foreach(ProjectNode project in solution.Projects)
+ {
+ if(count == 0)
+ ss.WriteLine(" ", project.Name);
+
+ ss.WriteLine(" ", project.Name);
+ count++;
+ }
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+ foreach(ProjectNode project in solution.Projects)
+ {
+ string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+ ss.WriteLine(" ",
+ Helper.MakeFilePath(path, project.Name, "prjx"));
+ }
+ ss.WriteLine(" ");
+
+ count = 0;
+ foreach(ConfigurationNode conf in solution.Configurations)
+ {
+ if(count == 0)
+ {
+ ss.WriteLine(" ", conf.Name);
+ }
+
+ ss.WriteLine(" ", conf.Name);
+ foreach(ProjectNode project in solution.Projects)
+ {
+ ss.WriteLine(" ", project.Name, conf.Name);
+ }
+ ss.WriteLine(" ");
+
+ count++;
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine("");
+ }
+
+ 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
+
+ ///
+ /// Writes the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Cleans the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ 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
+{
+ ///
+ ///
+ ///
+ public struct ToolInfo
+ {
+ string name;
+ string guid;
+ string fileExtension;
+ string xmlTag;
+ string importProject;
+
+ ///
+ /// Gets or sets the name.
+ ///
+ /// The name.
+ public string Name
+ {
+ get
+ {
+ return name;
+ }
+ set
+ {
+ name = value;
+ }
+ }
+
+ ///
+ /// Gets or sets the GUID.
+ ///
+ /// The GUID.
+ public string Guid
+ {
+ get
+ {
+ return guid;
+ }
+ set
+ {
+ guid = value;
+ }
+ }
+
+ ///
+ /// Gets or sets the file extension.
+ ///
+ /// The file extension.
+ 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";
+ }
+ }
+ }
+ ///
+ /// Gets or sets the XML tag.
+ ///
+ /// The XML tag.
+ public string XmlTag
+ {
+ get
+ {
+ return xmlTag;
+ }
+ set
+ {
+ xmlTag = value;
+ }
+ }
+
+ ///
+ /// Gets or sets the import project property.
+ ///
+ /// The ImportProject tag.
+ public string ImportProject
+ {
+ get
+ {
+ return importProject;
+ }
+ set
+ {
+ importProject = value;
+ }
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The name.
+ /// The GUID.
+ /// The file extension.
+ /// The XML.
+ /// The import project.
+ 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;
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The name.
+ /// The GUID.
+ /// The file extension.
+ /// The XML.
+ 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";
+ }
+
+ ///
+ /// Equals operator
+ ///
+ /// ToolInfo to compare
+ /// true if toolInfos are equal
+ 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));
+ }
+
+ ///
+ /// Equals operator
+ ///
+ /// ToolInfo to compare
+ /// ToolInfo to compare
+ /// True if toolInfos are equal
+ 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));
+ }
+
+ ///
+ /// Not equals operator
+ ///
+ /// ToolInfo to compare
+ /// ToolInfo to compare
+ /// True if toolInfos are not equal
+ public static bool operator !=(ToolInfo c1, ToolInfo c2)
+ {
+ return !(c1 == c2);
+ }
+
+ ///
+ /// Hash Code
+ ///
+ /// Hash code
+ 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
+{
+ ///
+ ///
+ ///
+ [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
+
+ ///
+ /// Writes the specified kern.
+ ///
+ /// The kern.
+ public override void Write(Kernel kern)
+ {
+ SetVS2002();
+ base.Write(kern);
+ }
+
+ ///
+ /// Cleans the specified kern.
+ ///
+ /// The kern.
+ public override void Clean(Kernel kern)
+ {
+ SetVS2002();
+ base.Clean(kern);
+ }
+
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ 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 m_Tools = new Dictionary();
+ Kernel m_Kernel;
+
+ ///
+ /// Gets or sets the solution version.
+ ///
+ /// The solution version.
+ protected string SolutionVersion
+ {
+ get
+ {
+ return solutionVersion;
+ }
+ set
+ {
+ solutionVersion = value;
+ }
+ }
+ ///
+ /// Gets or sets the product version.
+ ///
+ /// The product version.
+ protected string ProductVersion
+ {
+ get
+ {
+ return productVersion;
+ }
+ set
+ {
+ productVersion = value;
+ }
+ }
+ ///
+ /// Gets or sets the schema version.
+ ///
+ /// The schema version.
+ protected string SchemaVersion
+ {
+ get
+ {
+ return schemaVersion;
+ }
+ set
+ {
+ schemaVersion = value;
+ }
+ }
+ ///
+ /// Gets or sets the name of the version.
+ ///
+ /// The name of the version.
+ protected string VersionName
+ {
+ get
+ {
+ return versionName;
+ }
+ set
+ {
+ versionName = value;
+ }
+ }
+ ///
+ /// Gets or sets the version.
+ ///
+ /// The version.
+ protected VSVersion Version
+ {
+ get
+ {
+ return version;
+ }
+ set
+ {
+ version = value;
+ }
+ }
+
+ #endregion
+
+ #region Constructors
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ 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("");
+ 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");
+ ps.WriteLine(" ");
+
+ foreach(ConfigurationNode conf in project.Configurations)
+ {
+ ps.WriteLine("\t\t\t\t ");
+ }
+
+ ps.WriteLine(" ");
+
+ ps.WriteLine(" ");
+ foreach(ReferenceNode refr in project.References)
+ {
+ ps.WriteLine(" ");
+ }
+ ps.WriteLine(" ");
+
+ ps.WriteLine(" ");
+ ps.WriteLine(" ");
+
+ ps.WriteLine(" ");
+
+ foreach(string file in project.Files)
+ {
+ string fileName = file.Replace(".\\", "");
+ ps.WriteLine(" ");
+
+ if (project.Files.GetSubType(file) != SubType.Code && project.Files.GetSubType(file) != SubType.Settings)
+ {
+ ps.WriteLine(" ");
+
+ }
+ }
+ ps.WriteLine(" ");
+
+ ps.WriteLine(" ");
+ ps.WriteLine(" {0}>", toolInfo.XmlTag);
+ ps.WriteLine("");
+ }
+
+ ps = new StreamWriter(projectFile + ".user");
+ using(ps)
+ {
+ ps.WriteLine("");
+ ps.WriteLine(" <{0}>", toolInfo.XmlTag);
+ ps.WriteLine(" ");
+
+ ps.WriteLine(" ", MakeRefPath(project));
+ foreach(ConfigurationNode conf in project.Configurations)
+ {
+ ps.WriteLine(" ");
+ }
+ ps.WriteLine(" ");
+
+ ps.WriteLine(" ");
+ ps.WriteLine(" {0}>", toolInfo.XmlTag);
+ ps.WriteLine("");
+ }
+
+ m_Kernel.CurrentWorkingDirectory.Pop();
+ }
+
+ ///
+ /// Gets the XML doc file.
+ ///
+ /// The project.
+ /// The conf.
+ ///
+ 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
+
+ ///
+ /// Writes the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Cleans the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ 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
+{
+ ///
+ ///
+ ///
+ [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;
+ }
+ ///
+ /// Gets or sets the solution version.
+ ///
+ /// The solution version.
+ public override string SolutionVersion
+ {
+ get
+ {
+ return solutionVersion;
+ }
+ }
+ ///
+ /// Gets or sets the product version.
+ ///
+ /// The product version.
+ public override string ProductVersion
+ {
+ get
+ {
+ return productVersion;
+ }
+ }
+ ///
+ /// Gets or sets the schema version.
+ ///
+ /// The schema version.
+ public override string SchemaVersion
+ {
+ get
+ {
+ return schemaVersion;
+ }
+ }
+ ///
+ /// Gets or sets the name of the version.
+ ///
+ /// The name of the version.
+ public override string VersionName
+ {
+ get
+ {
+ return versionName;
+ }
+ }
+ ///
+ /// Gets or sets the version.
+ ///
+ /// The version.
+ public override VSVersion Version
+ {
+ get
+ {
+ return version;
+ }
+ }
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ public override string Name
+ {
+ get
+ {
+ return name;
+ }
+ }
+
+ #endregion
+
+ #region Constructors
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ 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
+{
+
+ ///
+ ///
+ ///
+ [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;
+
+ ///
+ /// Gets or sets the solution version.
+ ///
+ /// The solution version.
+ public override string SolutionVersion
+ {
+ get
+ {
+ return solutionVersion;
+ }
+ }
+ ///
+ /// Gets or sets the product version.
+ ///
+ /// The product version.
+ public override string ProductVersion
+ {
+ get
+ {
+ return productVersion;
+ }
+ }
+ ///
+ /// Gets or sets the schema version.
+ ///
+ /// The schema version.
+ public override string SchemaVersion
+ {
+ get
+ {
+ return schemaVersion;
+ }
+ }
+ ///
+ /// Gets or sets the name of the version.
+ ///
+ /// The name of the version.
+ public override string VersionName
+ {
+ get
+ {
+ return versionName;
+ }
+ }
+ ///
+ /// Gets or sets the version.
+ ///
+ /// The version.
+ public override VSVersion Version
+ {
+ get
+ {
+ return version;
+ }
+ }
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ 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
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ 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
+{
+
+ ///
+ ///
+ ///
+ [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
+
+ ///
+ /// Gets or sets the solution version.
+ ///
+ /// The solution version.
+ public override string SolutionVersion
+ {
+ get
+ {
+ return solutionVersion;
+ }
+ }
+
+ ///
+ /// Gets or sets the product version.
+ ///
+ /// The product version.
+ public override string ProductVersion
+ {
+ get
+ {
+ return productVersion;
+ }
+ }
+
+ ///
+ /// Gets or sets the schema version.
+ ///
+ /// The schema version.
+ public override string SchemaVersion
+ {
+ get
+ {
+ return schemaVersion;
+ }
+ }
+
+ ///
+ /// Gets or sets the name of the version.
+ ///
+ /// The name of the version.
+ public override string VersionName
+ {
+ get
+ {
+ return versionName;
+ }
+ }
+
+ ///
+ /// Gets or sets the version.
+ ///
+ /// The version.
+ public override VSVersion Version
+ {
+ get
+ {
+ return version;
+ }
+ }
+
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ 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
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ 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
+{
+
+ ///
+ ///
+ ///
+ public abstract class VSGenericTarget : ITarget
+ {
+ #region Fields
+
+ readonly Dictionary tools = new Dictionary();
+ Kernel kernel;
+ #endregion
+
+ #region Properties
+ ///
+ /// Gets or sets the solution version.
+ ///
+ /// The solution version.
+ public abstract string SolutionVersion { get; }
+ ///
+ /// Gets or sets the product version.
+ ///
+ /// The product version.
+ public abstract string ProductVersion { get; }
+ ///
+ /// Gets or sets the schema version.
+ ///
+ /// The schema version.
+ public abstract string SchemaVersion { get; }
+ ///
+ /// Gets or sets the name of the version.
+ ///
+ /// The name of the version.
+ public abstract string VersionName { get; }
+ ///
+ /// Gets or sets the version.
+ ///
+ /// The version.
+ public abstract VSVersion Version { get; }
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ public abstract string Name { get; }
+
+ protected abstract string GetToolsVersionXml(FrameworkVersion version);
+ public abstract string SolutionTag { get; }
+
+ #endregion
+
+ #region Constructors
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ 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("", GetToolsVersionXml(project.FrameworkVersion));
+ ps.WriteLine(" ");
+ ps.WriteLine(" Local");
+ ps.WriteLine(" {0}", ProductVersion);
+ ps.WriteLine(" {0}", SchemaVersion);
+ ps.WriteLine(" {{{0}}}", project.Guid.ToString().ToUpper());
+
+ // Visual Studio has a hard coded guid for the project type
+ if (project.Type == ProjectType.Web)
+ ps.WriteLine(" {349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}");
+ ps.WriteLine(" Debug");
+ ps.WriteLine(" {0}", project.AppIcon);
+ ps.WriteLine(" ");
+ ps.WriteLine(" ");
+ ps.WriteLine(" {0}", project.AssemblyName);
+ foreach (ConfigurationNode conf in project.Configurations)
+ {
+ if (conf.Options.KeyFile != "")
+ {
+ ps.WriteLine(" {0}", conf.Options.KeyFile);
+ ps.WriteLine(" true");
+ break;
+ }
+ }
+ ps.WriteLine(" JScript");
+ ps.WriteLine(" Grid");
+ ps.WriteLine(" IE50");
+ ps.WriteLine(" false");
+ ps.WriteLine(" {0}", project.FrameworkVersion.ToString().Replace("_", "."));
+
+ ps.WriteLine(" {0}", project.Type == ProjectType.Web ? ProjectType.Library.ToString() : project.Type.ToString());
+ ps.WriteLine(" {0}", project.DesignerFolder);
+ ps.WriteLine(" {0}", project.RootNamespace);
+ ps.WriteLine(" {0}", project.StartupObject);
+ if (string.IsNullOrEmpty(project.DebugStartParameters))
+ {
+ ps.WriteLine(" {0}", project.DebugStartParameters);
+ }
+ ps.WriteLine(" ");
+ ps.WriteLine(" ");
+
+ ps.WriteLine(" ");
+
+ foreach (ConfigurationNode conf in project.Configurations)
+ {
+ ps.Write(" ", conf.Name, conf.Platform);
+ ps.WriteLine(" {0}", conf.Options["AllowUnsafe"]);
+ ps.WriteLine(" {0}", conf.Options["BaseAddress"]);
+ ps.WriteLine(" {0}", conf.Options["CheckUnderflowOverflow"]);
+ ps.WriteLine(" ");
+ ps.WriteLine(" ");
+ ps.WriteLine(" {0}", conf.Options["CompilerDefines"]);
+ ps.WriteLine(" {0}", Helper.NormalizePath(conf.Options["XmlDocFile"].ToString()));
+ ps.WriteLine(" {0}", conf.Options["DebugInformation"]);
+ ps.WriteLine(" {0}", conf.Options["FileAlignment"]);
+ ps.WriteLine(" {0}", conf.Options["OptimizeCode"]);
+ if (project.Type != ProjectType.Web)
+ ps.WriteLine(" {0}",
+ Helper.EndPath(Helper.NormalizePath(conf.Options["OutputPath"].ToString())));
+ else
+ ps.WriteLine(" {0}",
+ Helper.EndPath(Helper.NormalizePath("bin\\")));
+
+ ps.WriteLine(" {0}", conf.Options["RegisterComInterop"]);
+ ps.WriteLine(" {0}", conf.Options["RemoveIntegerChecks"]);
+ ps.WriteLine(" {0}", conf.Options["WarningsAsErrors"]);
+ ps.WriteLine(" {0}", conf.Options["WarningLevel"]);
+ ps.WriteLine(" {0}", conf.Options["NoStdLib"]);
+ ps.WriteLine(" {0}", conf.Options["SuppressWarnings"]);
+ ps.WriteLine(" {0}", conf.Platform);
+ ps.WriteLine(" ");
+ }
+
+ //ps.WriteLine(" ");
+
+ Dictionary projectReferences = new Dictionary();
+ List otherReferences = new List();
+
+ 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(" ");
+
+ foreach (ReferenceNode refr in otherReferences)
+ {
+ ps.Write(" ");
+ ps.Write(" ");
+ ps.Write(refr.Name);
+ ps.WriteLine("");
+
+ 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(" {0}", Helper.MakeFilePath(refr.Path, refr.Name, "exe"));
+ } else if(File.Exists(Helper.MakeFilePath(absolutePath, refr.Name, "dll"))) {
+ // Assembly is an library (dll)
+ ps.WriteLine(" {0}", 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(" {0}", Helper.MakeFilePath(refr.Path, refr.Name, "dll"));
+ }
+ }
+
+ ps.WriteLine(" {0}", refr.LocalCopy);
+ ps.WriteLine(" ");
+ }
+ ps.WriteLine(" ");
+
+ //Project References
+ ps.WriteLine(" ");
+ foreach (KeyValuePair 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(" ", path);
+
+ // TODO: Allow reference to visual basic projects
+ ps.WriteLine(" {0}", pair.Value.Name);
+ ps.WriteLine(" {0}", pair.Value.Guid.ToString("B").ToUpper());
+ ps.WriteLine(" {0}", tool.Guid.ToUpper());
+
+ //This is the Copy Local flag in VS
+ ps.WriteLine(" {0}", pair.Key.LocalCopy);
+
+ ps.WriteLine(" ");
+ }
+ ps.WriteLine(" ");
+
+ // ps.WriteLine(" ");
+ ps.WriteLine(" ");
+
+ // ps.WriteLine(" ");
+ List list = new List();
+
+ 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(" ", file.Substring(0, file.LastIndexOf('.')) + ".resx");
+ ps.WriteLine(" {0}", Path.GetFileName(file));
+ ps.WriteLine(" Designer");
+ ps.WriteLine(" ");
+ //
+ }
+
+ if (subType == SubType.Designer)
+ {
+ ps.WriteLine(" ", 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(" {0}", Path.GetFileName(dependent_name));
+ }
+ else
+ {
+ ps.WriteLine(" ResXFileCodeGenerator");
+ ps.WriteLine(" {0}", Path.GetFileName(autogen_name));
+ ps.WriteLine(" " + subType + "");
+ }
+
+ ps.WriteLine(" ");
+ if (File.Exists(Helper.NormalizePath(autogen_name)))
+ {
+ ps.WriteLine(" ", autogen_name);
+ //ps.WriteLine(" True");
+
+ // 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(" {0}", Path.GetFileName(dependent_name));
+ }
+ else
+ {
+ ps.WriteLine(" True");
+ ps.WriteLine(" {0}", Path.GetFileName(filePath));
+ }
+
+ ps.WriteLine(" ");
+ }
+ 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(" SettingsSingleFileGenerator");
+ ps.WriteLine(" {0}", fileName.Substring(0, fileName.LastIndexOf('.')) + ".Designer.cs");
+ }
+ else
+ {
+ ps.WriteLine(" Code");
+ ps.WriteLine(" True");
+ ps.WriteLine(" True");
+ string fileNameShort = fileName.Substring(0, fileName.LastIndexOf('.'));
+ string fileNameShorter = fileNameShort.Substring(0, fileNameShort.LastIndexOf('.'));
+ ps.WriteLine(" {0}", 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(" {0}", Path.GetFileName(file_name + extension));
+ else if (File.Exists(file_name + ".resx"))
+ ps.WriteLine(" {0}", Path.GetFileName(file_name + ".resx"));
+ else if (File.Exists(file_name + ".settings"))
+ {
+ ps.WriteLine(" {0}", Path.GetFileName(file_name + ".settings"));
+ ps.WriteLine(" True");
+ ps.WriteLine(" True");
+ }
+ }
+ else if (subType == SubType.CodeBehind)
+ {
+ ps.WriteLine(" {0}", 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(" {0}", alias);
+ }
+ else if (project.Files.GetBuildAction(filePath) != BuildAction.None)
+ {
+ if (project.Files.GetBuildAction(filePath) != BuildAction.EmbeddedResource)
+ {
+ ps.WriteLine(" {0}", subType);
+ }
+ }
+
+ if (project.Files.GetCopyToOutput(filePath) != CopyToOutput.Never)
+ {
+ ps.WriteLine(" {0}", project.Files.GetCopyToOutput(filePath));
+ }
+
+ ps.WriteLine(" {0}>", project.Files.GetBuildAction(filePath));
+ }
+ }
+ }
+
+ ps.WriteLine(" ");
+ ps.WriteLine(" ");
+ ps.WriteLine(" ");
+ ps.WriteLine(" ");
+ ps.WriteLine(" ");
+ ps.WriteLine(" ");
+ ps.WriteLine(" ");
+ ps.WriteLine(" ");
+ ps.WriteLine("");
+ }
+ #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("");
+ //ps.WriteLine( "" );
+ //ps.WriteLine(" <{0}>", toolInfo.XMLTag);
+ //ps.WriteLine(" ");
+ ps.WriteLine(" ");
+ //ps.WriteLine(" ", MakeRefPath(project));
+
+ if (firstConfiguration != null)
+ {
+ ps.WriteLine(" {0}", firstConfiguration.Name);
+ ps.WriteLine(" {0}", firstConfiguration.Platform);
+ }
+
+ ps.WriteLine(" {0}", MakeRefPath(project));
+ ps.WriteLine(" {0}", ProductVersion);
+ ps.WriteLine(" ProjectFiles");
+ ps.WriteLine(" 0");
+ ps.WriteLine(" ");
+ foreach (ConfigurationNode conf in project.Configurations)
+ {
+ ps.Write(" ");
+ }
+ ps.WriteLine("");
+ }
+ #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 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
+
+ ///
+ /// Writes the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Cleans the specified kern.
+ ///
+ /// The kern.
+ 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
+{
+ ///
+ ///
+ ///
+ public enum VSVersion
+ {
+ ///
+ /// Visual Studio 2002
+ ///
+ VS70,
+ ///
+ /// Visual Studio 2003
+ ///
+ VS71,
+ ///
+ /// Visual Studio 2005
+ ///
+ VS80,
+ ///
+ /// Visual Studio 2008
+ ///
+ VS90,
+ ///
+ /// Visual Studio 2010
+ ///
+ 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
+{
+ ///
+ ///
+ ///
+ [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;
+ }
+
+ ///
+ /// Gets the XML doc file.
+ ///
+ /// The project.
+ /// The conf.
+ ///
+ 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("");
+ ss.WriteLine("", project.Name);
+ ss.WriteLine(" ", "build");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ foreach (ReferenceNode refr in project.References)
+ {
+ if (refr.LocalCopy)
+ {
+ ss.WriteLine(" ", '/'));
+ }
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.Write(" ");
+ ss.WriteLine(" ", project.RootNamespace);
+ foreach (string file in project.Files)
+ {
+ switch (project.Files.GetBuildAction(file))
+ {
+ case BuildAction.EmbeddedResource:
+ ss.WriteLine(" {0}", "");
+ break;
+ default:
+ if (project.Files.GetSubType(file) != SubType.Code && project.Files.GetSubType(file) != SubType.Settings)
+ {
+ ss.WriteLine(" ", file.Substring(0, file.LastIndexOf('.')) + ".resx");
+ }
+ break;
+ }
+ }
+ //if (project.Files.GetSubType(file).ToString() != "Code")
+ //{
+ // ps.WriteLine(" ", file.Substring(0, file.LastIndexOf('.')) + ".resx");
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ foreach (string file in project.Files)
+ {
+ switch (project.Files.GetBuildAction(file))
+ {
+ case BuildAction.Compile:
+ ss.WriteLine(" ");
+ break;
+ default:
+ break;
+ }
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ foreach (ReferenceNode refr in project.References)
+ {
+ ss.WriteLine(" ", '/'));
+ }
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+
+ ss.WriteLine(" ");
+ if (hasDoc)
+ {
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.Write(" ");
+ }
+ else
+ {
+ ss.WriteLine(".exe\" />");
+ }
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ // foreach(ReferenceNode refr in project.References)
+ // {
+ // string path = Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReferencePath(solution, refr)), '/');
+ // if (path != "")
+ // {
+ // ss.WriteLine(" ", path);
+ // }
+ // }
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine("");
+ }
+ 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("");
+ ss.WriteLine("", solution.Name);
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ //ss.WriteLine(" ");
+ //ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+
+ foreach (ConfigurationNode conf in solution.Configurations)
+ {
+ // Set the project.config to a non-debug configuration
+ if (conf.Options["DebugInformation"].ToString().ToLower() != "true")
+ {
+ ss.WriteLine(" ", conf.Name);
+ }
+ ss.WriteLine();
+ ss.WriteLine(" ", conf.Name);
+ ss.WriteLine(" ", conf.Name);
+ ss.WriteLine(" ", conf.Options["DebugInformation"].ToString().ToLower());
+ ss.WriteLine(" ");
+ ss.WriteLine();
+ }
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ //ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ //foreach(ProjectNode project in solution.Projects)
+ //{
+ // string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+ // ss.Write(" ");
+ //}
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+
+ foreach (ProjectNode project in solution.ProjectsTableOrder)
+ {
+ string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+ ss.Write(" ");
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine();
+ ss.WriteLine(" ");
+ ss.WriteLine();
+ //ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ ss.WriteLine();
+
+ ss.WriteLine(" ");
+ ss.WriteLine(" ");
+ foreach (ProjectNode project in solution.Projects)
+ {
+ string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+ ss.Write(" ");
+ }
+ ss.WriteLine(" ");
+ ss.WriteLine();
+ ss.WriteLine("");
+ }
+
+ 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
+
+ ///
+ /// Writes the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Cleans the specified kern.
+ ///
+ /// The kern.
+ 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;
+ }
+
+ ///
+ /// Gets the name.
+ ///
+ /// The name.
+ public string Name
+ {
+ get
+ {
+ return "xcode";
+ }
+ }
+
+ #endregion
+ }
+}
--
cgit v1.1