boo-lang-boo/default.build

<?xml version="1.0"?>
<project name="boo" default="all">

	<loadfile file="version.txt" property="version.txt" />
	<property name="boo.version" value="${string::trim(version.txt)}" />

	<!-- freeze AssemblyVersion to avoid backwards compatibility issues -->
	<property name="boo.assembly.version" value="2.0.9.5" />

	<property name="debug" value="true" />
	<property name="optimize" value="false" />
	<property name="verbose" value="false" />
	<property name="defines" value="" unless="${property::exists('defines')}" />

	<property name="mono" value="${'mono' == framework::get-family(framework::get-runtime-framework())}" />
	<property name="mono-framework-dir" value="${framework::get-framework-directory(framework::get-target-framework())}\..\..\.." if="${mono}" />
	<property name="mono-bin-dir" value="${mono-framework-dir}\bin" if="${mono}" />

	<property name="java" value="java" />
	<property name="antlr.jar" value="lib/antlr-2.7.5/antlr-2.7.5.jar" />
	<property name="antlr.trace" value="False" />

	<property name="ngen.exe" value="${framework::get-framework-directory(framework::get-target-framework())}/ngen.exe" />
	<property name="skip.ngen" value="True" />
	<property name="skip.antlr" value="False" />
	<property name="skip.ast" value="False" />
	<property name="skip.vs" value="False" />
	<property name="skip.errorpatterns" value="False" />

	<property name="gsv.name" value="gtksourceview-1.0" />

	<property name="build.dir" value="build" dynamic="True"/>
	<property name="distrobuild.dir" value="distrobuild"/>
	<property name="docs.dir" value="docs" />
	<property name="examples.dir" value="examples" />

	<property name="install.prefix" value="/usr/local" />
	<property name="install.destdir" value="/" />

	<property name="install.share" value="${path::combine(install.prefix,'share')}" />
	<property name="install.bindir" value="${path::combine(install.prefix,'bin')}" />
	<property name="install.libdir" value="${path::combine(install.prefix,'lib')}" />
	<property name="install.docsdir" value="${path::combine(install.prefix, docs.dir)}" />
	<property name="install.examplesdir" value="${path::combine(install.prefix, examples.dir)}" />
	<property name="install.boolib" value="${path::combine(install.libdir,'boo')}" />
	<property name="install.boodocs" value="${path::combine(install.docsdir,'boo')}" />
	<property name="install.booexamples" value="${path::combine(install.examplesdir,'boo')}" />

	<property name="fakeroot" value="${install.destdir}" />
	<property name="fakeroot.boolib" value="${install.destdir}/${install.boolib}" />
	<property name="fakeroot.boodocs" value="${install.destdir}/${install.boodocs}" />
	<property name="fakeroot.booexamples" value="${install.destdir}/${install.booexamples}" />
	<property name="fakeroot.bindir" value="${install.destdir}/${install.bindir}" />
	<property name="fakeroot.libdir" value="${install.destdir}/${install.libdir}" />
	<property name="fakeroot.share" value="${install.destdir}/${install.share}" />

	<!-- set gendarme.dir in your build.properties to enable Gendarme report after build -->
	<property name="gendarme.dir" value=""/>
	<!-- set gendarme.set to 'boo' to get only Gendarme.Rules.Boo defects -->
	<property name="gendarme.set" value=""/>

	<include buildfile="build.properties" if="${file::exists('build.properties')}" />

	<property name="boo.distro.name" value="boo-${boo.version}" />

	<property name="supported.runtimes.net-1.1" value="&lt;supportedRuntime version=&quot;v1.1.4322&quot;/&gt;
&lt;supportedRuntime version=&quot;v2.0.50727&quot;/&gt;" />

	<property name="supported.runtimes.net-2.0"
		value="&lt;supportedRuntime version=&quot;v2.0.50727&quot;/&gt;
&lt;supportedRuntime version=&quot;v1.1.4322&quot;/&gt;" />

	<property name="supported.runtimes.net-4.0"
		value="&lt;supportedRuntime version=&quot;v4.0.30319&quot;/&gt;
&lt;supportedRuntime version=&quot;v2.0.50727&quot;/&gt;
&lt;supportedRuntime version=&quot;v1.1.4322&quot;/&gt;" />

	<property name="net40" value="${version::get-major(framework::get-version(framework::get-target-framework())) &gt;= 4}" />

	<!-- Tests whether the target .NET platform is 4.0 or not -->
	<if test="${net40}">
		<property name="supported.runtimes" value="${supported.runtimes.net-4.0}" />
		<property name="csc.4.define" value="NET_4_0;" />
	</if>

	<if test="${not net40}">
		<property name="supported.runtimes" value="${supported.runtimes.net-2.0}" />
		<property name="csc.4.define" value="" />
	</if>

	<property name="csc.noconfig" value="false" />
	<property name="csc.define.custom" value="NO_CUSTOM_DEFINE" unless="${property::exists('csc.define.custom')}" />
	<property name="csc.define" value="${csc.4.define}NET_2_0;TRACE;DEBUG;${csc.define.custom}" />

	<property name="fixture" value="" dynamic="true" />

	<property name="nosign" value="false" />

	<property name="nant-csc-keyfile-bug" value="${version::get-minor(assemblyname::get-version(assembly::get-name(nant::get-assembly()))) &lt; 86}" />

	<target name="sign">
		<property name="keyfile.path" value="src/boo.snk" overwrite="false" />
	</target>

	<target name="nosign">
		<property name="keyfile.path" value="" overwrite="false" />
		<property name="nosign" value="true" overwrite="true" />
	</target>

	<target name="all" depends="booc, booi, booish, boo-pkgconfig, Boo.Lang.CodeDom, Boo.Lang.Useful, Boo.Microsoft.Build.Tasks, update-vs-env, Boo.Lang.PatternMatching">
		<call target="gendarme" if="${gendarme.dir != ''}" />
		<call target="verify-assemblies" />
	</target>

	<target name="verify-assemblies" if="${mono}">
		<foreach item="File" property="filename">
		<in>
			<items>
				<include name="${build.dir}/Boo.Lang*.dll" />
			</items>
		</in>
		<do>
			<exec program="${mono-bin-dir}/pedump" workingdir="${build.dir}">
				<environment>
					<variable name="MONO_PATH" path="${build.dir}" />
				</environment>
				<arg line="--verify code" />
				<arg value="${path::get-file-name(filename)}" />
			</exec>
		</do>
		</foreach>
	</target>

	<target name="set-release-configuration">
		<property name="debug" value="false" />
		<property name="optimize" value="true" />
		<property name="csc.define" value="NET_2_0;${csc.define.custom}" />
	</target>

	<target name="nostdlib">
		<property name="csc.define" value="${csc.define};NO_SYSTEM_DLL" />
		<property name="csc.noconfig" value="true" />
	</target>

	<target name="test" depends="all">
		<exec
			basedir="${nant::get-base-directory()}"
			program="NAnt.exe"
			workingdir="tests"
			useruntimeengine="true">
			<arg value="-t:${framework::get-target-framework()}" />
			<arg value="-D:fixture=${fixture}" if="${fixture != ''}" />
			<arg value="run" />
		</exec>
	</target>

	<target name="test-vs-bin">
		<exec
			basedir="${nant::get-base-directory()}"
			program="NAnt.exe"
			workingdir="tests"
			useruntimeengine="true">
			<arg value="-D:fixture=${fixture}" if="${fixture != ''}" />
			<arg value="run-vs-bin" />
		</exec>
	</target>

	<target name="compile-tests" depends="all">
		<exec
			basedir="${nant::get-base-directory()}"
			program="NAnt.exe"
			workingdir="tests"
			useruntimeengine="true">
			<arg value="-D:fixture=${fixture}" if="${fixture != ''}" />
			<arg value="compile" />
		</exec>
	</target>

	<target name="booish" depends="Boo.Lang.Interpreter">
		<booc
			target="exe"
			output="${build.dir}/booish.exe"
			verbose="${verbose}"
			debug="${debug}"
			define="${defines}">

			<sources basedir="src/booish">
				<include name="*.boo" />
			</sources>

			<references basedir="${build.dir}">
				<include name="Boo.Lang.Interpreter.dll" />
				<include name="Boo.Lang.Compiler.dll" />
			</references>
			<arg line="-keyfile:${keyfile.path}" unless="${keyfile.path == ''}" />
		</booc>

		<copy file="extras/template.config.in" tofile="${build.dir}/booish.exe.config">
			<filterchain>
				<replacestring from="@SUPPORTEDVERSIONS@"
					to="${supported.runtimes}" />
			</filterchain>
		</copy>

		<if test="${not(platform::is-windows())}">
			<copy file="extras/booish.in" tofile="${build.dir}/booish" inputencoding="ASCII">
				<filterchain>
					<replacestring from="@RUNTIME@" to="mono" />
					<replacestring from="@prefix@" to="${install.prefix}" />
					<replacestring from="@libdir@" to="${install.libdir}" />
				</filterchain>
			</copy>
		</if>
	</target>

	<target name="booi" depends="core, Boo.Lang.Useful, Boo.Lang.Parser">
		<booc
			target="exe"
			output="${build.dir}/booi.exe"
			verbose="${verbose}"
			debug="${debug}"
			define="${defines}">

			<references basedir="${build.dir}">
				<include name="Boo.Lang.Parser.dll" />
				<include name="Boo.Lang.Compiler.dll" />
				<include name="Boo.Lang.Useful.dll" />
			</references>

			<sources basedir="src/booi">
				<include name="*.boo" />
			</sources>
			<arg line="-keyfile:${keyfile.path}" unless="${keyfile.path == ''}" />
		</booc>

		<copy file="extras/template.config.in" tofile="${build.dir}/booi.exe.config">
			<filterchain>
				<replacestring from="@SUPPORTEDVERSIONS@"
					to="${supported.runtimes}" />
			</filterchain>
		</copy>

		<if test="${not(platform::is-windows())}">
			<copy file="extras/booi.in" tofile="${build.dir}/booi" inputencoding="ASCII">
				<filterchain>
					<replacestring from="@RUNTIME@" to="mono" />
					<replacestring from="@prefix@" to="${install.prefix}" />
					<replacestring from="@libdir@" to="${install.libdir}" />
				</filterchain>
			</copy>
		</if>

		<boo>
		print("Hello from boo task!")
		print("Framework directory: ${Project.TargetFramework.FrameworkAssemblyDirectory}")
		</boo>

	</target>

	<target name="dump-properties" depends="core">
		<boo>
		for p as System.Collections.DictionaryEntry in Project.Properties:
			print("${p.Key}: ${p.Value}")
		</boo>
	</target>

	<target name="Boo.Lang.PatternMatching" depends="core">

		<booc target="library" output="${build.dir}/Boo.Lang.PatternMatching.dll">
			<sources basedir="src/Boo.Lang.PatternMatching">
				<include name="**/*.boo" />
			</sources>
			<arg line="-keyfile:${keyfile.path}" unless="${keyfile.path == ''}" />
		</booc>

	</target>

	<target name="Boo.Lang.Interpreter" depends="Boo.Lang.PatternMatching, core">
		<booc target="library"
		      output="${build.dir}/Boo.Lang.Interpreter.dll"
		      verbose="${verbose}"
		      debug="${debug}"
		      define="${defines}">
			<sources basedir="src/Boo.Lang.Interpreter">
				<include name="**/*.boo" />
			</sources>
			<references basedir="${build.dir}">
				<include name="Boo.Lang.Compiler.dll" />
				<include name="Boo.Lang.PatternMatching.dll" />
			</references>
			<arg line="-keyfile:${keyfile.path}" unless="${keyfile.path == ''}" />
		</booc>
	</target>

	<target name="Boo.NAnt.Tasks" depends="booc">
		<uptodate property="Boo.NAnt.Tasks-is-uptodate">
			<sourcefiles basedir="src/Boo.NAnt.Tasks">
				<include name="*.boo" />
			</sourcefiles>
			<targetfiles>
				<include name="${build.dir}/Boo.NAnt.Tasks.dll" />
			</targetfiles>
		</uptodate>

		<if test="${debug}">
			<property name="debugflag" value="-debug"/>
		</if>
		<if test="${not debug}">
			<property name="debugflag" value="-debug-"/>
		</if>

		<exec program="${build.dir}/booc.exe" useruntimeengine="true" unless="${Boo.NAnt.Tasks-is-uptodate}">
			<arg value="-v" />
			<arg value="-noconfig" />
			<arg value="${debugflag}" />
			<arg value="-out:${build.dir}/Boo.NAnt.Tasks.dll" />
			<arg value="-target:library" />
			<arg value="-r:NAnt.Core.dll" />
			<arg value="-r:NAnt.DotNetTasks.dll" />
			<arg value="-srcdir:src/Boo.NAnt.Tasks" />
			<arg line='"-lib:${nant::get-base-directory()}"' />
		</exec>

		<loadtasks assembly="${build.dir}/Boo.NAnt.Tasks.dll" />
	</target>

	<target name="booc" depends="corecs">
		<csc target="exe"
				output="${build.dir}/booc.exe"
				debug="${debug}"
				optimize="${optimize}"
				define="${csc.define}">
			<sources basedir="src/booc">
				<include name="*.cs" />
			</sources>

			<references>
				<include name="${build.dir}/Boo.Lang.dll" />
				<include name="${build.dir}/Boo.Lang.Compiler.dll" />
				<include name="${build.dir}/Boo.Lang.Parser.dll" />
			</references>
			<arg line="/keyfile:${keyfile.path}" unless="${keyfile.path == ''}" />
		</csc>

		<if test="${not(platform::is-windows())}">
			<copy file="extras/booc.in" tofile="${build.dir}/booc" inputencoding="ASCII">
				<filterchain>
					<replacestring from="@RUNTIME@" to="mono" />
					<replacestring from="@prefix@" to="${install.prefix}" />
					<replacestring from="@libdir@" to="${install.libdir}" />
				</filterchain>
			</copy>
		</if>

		<copy todir="${build.dir}" file="src/booc/booc.rsp" />

		<copy file="extras/template.config.in" tofile="${build.dir}/booc.exe.config">
			<filterchain>
				<replacestring from="@SUPPORTEDVERSIONS@"
					to="${supported.runtimes}" />
			</filterchain>
		</copy>

		<exec program='${ngen.exe}' if="${file::exists(ngen.exe)}" unless="${skip.ngen}">
			<arg file='${build.dir}/Boo.Lang.dll' />
			<arg file='${build.dir}/Boo.Lang.Compiler.dll' />
			<arg file='${build.dir}/Boo.Lang.Extensions.dll' />
			<arg file='${build.dir}/Boo.Lang.Parser.dll' />
			<arg file='${build.dir}/booc.exe' />
		</exec>
	</target>

	<target name="corecs" depends="Boo.Lang, Boo.Lang.Compiler, Boo.Lang.Parser">
	</target>

	<target name="core" depends="corecs, Boo.Lang.Extensions, Boo.NAnt.Tasks" />

	<target name="update-bin" depends="all">
		<mkdir dir="bin" />
		<delete>
			<fileset basedir="bin">
				<include name="*.Tasks.dll" />
				<include name="*.targets" />
				<include name="*.config" />
				<include name="*.exe" />
			</fileset>
		</delete>
		<copy todir="bin">
			<fileset basedir="${build.dir}">
				<include name="Boo.*.dll" />
				<include name="boo*.exe" />
				<include name="boo*.rsp" />
				<include name="*.config" />
				<include name="*.targets" />
			</fileset>
		</copy>
	</target>

	<target name="Boo.Microsoft.Build.Tasks" depends="core">
		<booc target="library"
			output="${build.dir}/Boo.Microsoft.Build.Tasks.dll"
			failonerror="true"
			verbose="${verbose}"
			debug="${debug}"
			define="${defines}">
			<sources basedir="src/Boo.Microsoft.Build.Tasks">
				<include name="**/*.boo" />
			</sources>
			<references basedir="${build.dir}">
				<include name="Microsoft.Build.Utilities.dll" />
				<include name="Microsoft.Build.Framework.dll" />
				<include name="Microsoft.Build.Tasks.dll" />
			</references>
			<arg line="-keyfile:${keyfile.path}" unless="${keyfile.path == ''}" />
		</booc>
		<copy todir="${build.dir}">
			<fileset basedir="src/Boo.Microsoft.Build.Tasks">
				<include name="Boo.Microsoft.Build.targets" />
			</fileset>
		</copy>
	</target>

	<target name="Boo.Lang.Useful" depends="core">
		<uptodate property="useful-grammars-uptodate">
			<sourcefiles basedir="src/Boo.Lang.Useful">
				<include name="**/*.g" />
			</sourcefiles>
			<targetfiles basedir="src/Boo.Lang.Useful">
				<include name="**/*Lexer.boo" />
			</targetfiles>
		</uptodate>

		<if test="${not useful-grammars-uptodate and not skip.antlr}">
			<exec program="${java}" failonerror="true">
				<arg value="-cp" />
				<arg file="${antlr.jar}" />
				<arg value="antlr.Tool" />
				<arg value="-o" />
				<arg value="src/Boo.Lang.Useful/IO/Impl" />
				<arg value="src/Boo.Lang.Useful/IO/PreProcessorExpressions.g" />
			</exec>
		</if>

		<booc target="library"
			output="${build.dir}/Boo.Lang.Useful.dll"
			verbose="${verbose}"
			debug="${debug}"
			define="${defines}">
			<nowarn>
				<warning number="BCW0016"/> <!-- unused namespaces in generated stuff -->
			</nowarn>
			<sources basedir="src/Boo.Lang.Useful">
				<include name="**/*.boo" />
			</sources>
			<references basedir="${build.dir}">
				<include name="Boo.Lang.Parser.dll" />
				<include name="Boo.Lang.Compiler.dll" />
			</references>
			<arg line="-keyfile:${keyfile.path}" unless="${keyfile.path == ''}" />
		</booc>
	</target>

	<target name="Boo.Lang.CodeDom" depends="core">
		<booc target="library"
			output="${build.dir}/Boo.Lang.CodeDom.dll"
			verbose="${verbose}"
			debug="${debug}"
			define="${defines}">
			<sources basedir="src/Boo.Lang.CodeDom">
				<include name="**/*.boo" />
			</sources>
			<references basedir="${build.dir}">
			<!--
				<include name="System.Data.dll" />
				<include name="System.Xml.dll" />
			-->
				<include name="Boo.Lang.Compiler.dll" />
			</references>
			<arg line="-keyfile:${keyfile.path}" unless="${keyfile.path == ''}" />
		</booc>
	</target>

	<target name="Boo.Lang.Extensions" depends="corecs, Boo.NAnt.Tasks">
		<booc target="library"
			output="${build.dir}/Boo.Lang.Extensions.dll"
			failonerror="true"
			nostdlib="true"
			verbose="${verbose}"
			debug="${debug}"
			define="${defines}">
			<sources basedir="src/Boo.Lang.Extensions">
				<include name="**/*.boo" />
			</sources>
			<references basedir="${build.dir}">
				<include name="Boo.Lang.dll" />
				<include name="Boo.Lang.Compiler.dll" />
				<include name="System.dll" />
				<include name="System.Core.dll" />
			</references>
			<arg line="-keyfile:${keyfile.path}" unless="${keyfile.path == ''}" />
		</booc>
	</target>


	<target name="Boo.Lang.Compiler" depends="Boo.Lang, Boo.Lang.Ast">
		<csc target="library"
			output="${build.dir}/Boo.Lang.Compiler.dll"
			debug="${debug}"
			optimize="${optimize}"
			define="${csc.define}">

			<sources basedir="src/Boo.Lang.Compiler">
				<include name="**/*.cs" />
			</sources>

			<references>
				<include name="${build.dir}/Boo.Lang.dll" />
				<include name="System.Numerics.dll" />
				<!--include name="${build.dir}/Boo.Lang.Ast.dll" /-->
			</references>
			<arg line="/keyfile:${keyfile.path}" unless="${keyfile.path == ''}" />
		</csc>
	</target>

	<target name="Boo.Lang.Ast" depends="Boo.Lang, generate-ast">
		<!--csc
			target="library"
			output="${build.dir}/Boo.Lang.Ast.dll"
			debug="${debug}"
			optimize="${optimize}"
			define="${csc.define}">

			<sources basedir="src/Boo.Lang.Ast">
				<include name="**/*.cs" />
			</sources>

			<references>
				<include name="${build.dir}/Boo.Lang.dll" />
			</references>
		</csc-->
	</target>

	<target name="Boo.Lang" depends="init">
		<csc
			target="library"
			output="${build.dir}/Boo.Lang.dll"
			debug="${debug}"
			optimize="${optimize}"
			define="${csc.define}"
			noconfig="${csc.noconfig}">

			<sources basedir="src/Boo.Lang">
				<include name="**/*.cs" />
			</sources>
			<nowarn>
				<warning if="${nant-csc-keyfile-bug}" number="1699"/>
			</nowarn>
			<arg line="/keyfile:${keyfile.path}" unless="${keyfile.path == '' or nant-csc-keyfile-bug}" />
		</csc>
	</target>

	<target name="boo-pkgconfig">
		<copy file="extras/boo.pc.in" tofile="${build.dir}/boo.pc" if="${not(platform::is-windows())}" inputencoding="ASCII">
			<filterchain>
				<replacestring from="@prefix@" to="${install.prefix}" />
				<replacestring from="@VERSION@" to="${boo.version}" />
			</filterchain>
		</copy>
	</target>

	<target name="install" depends="booc, booish, booi">
		<call target="install-win32" if="${platform::is-windows()}"/>
		<call target="install-linux" if="${not(platform::is-windows())}"/>
	</target>

	<target name="install-linux" depends="booc, booish, booi">
		<!--
		Use pkg-config to find the proper locations for several
		key files for mime detection, etc
		-->

		<property name="sharedmime.prefix" value="${pkg-config::get-variable('shared-mime-info','prefix')}" />
		<property name="fakeroot.sharedmime" value="${fakeroot}/${sharedmime.prefix}" />
		<property name="gsv.prefix" value="${pkg-config::get-variable(gsv.name,'prefix')}" />
		<property name="fakeroot.gsv" value="${fakeroot}/${gsv.prefix}" />

		<mkdir dir="${fakeroot.boolib}"/>
		<mkdir dir="${fakeroot.bindir}"/>

		<copy todir="${fakeroot.boolib}">
			<fileset basedir="${build.dir}">
				<include name="*.exe"/>
				<include name="*.rsp"/>
				<include name="*.config"/>
				<include name="*.targets"/>
				<include name="*.Tasks.dll" />
			</fileset>
		</copy>

		<foreach item="File" property="filename">
		<in>
			<items>
				<include name="${build.dir}/Boo.Lang*.dll" />
			</items>
		</in>
		<do>
			<exec program="gacutil" useruntimeengine="false" workingdir="${build.dir}">
				<arg value="/i" />
				<arg value="${path::get-file-name(filename)}" />
				<arg value="/package" />
				<arg value="boo" />
				<arg value="/root" />
				<arg value="${fakeroot.libdir}" />
			</exec>
		</do>
		</foreach>

		<copy todir="${fakeroot.bindir}">
			<fileset basedir="${build.dir}">
				<include name="booc"/>
				<include name="booish"/>
				<include name="booi"/>
			</fileset>
		</copy>

		<copy todir="${fakeroot.sharedmime}/share/mime-info">
			<fileset basedir="extras">
				<include name="boo.keys" />
				<include name="boo.mime" />
			</fileset>
		</copy>

		<copy file="extras/boo.lang" todir="${fakeroot.gsv}/share/${gsv.name}/language-specs/" />
		<copy file="${build.dir}/boo.pc" todir="${fakeroot.libdir}/pkgconfig/" />
		<copy file="extras/boo-mime-info.xml" todir="${fakeroot.sharedmime}/share/mime/packages/" />

		<exec program="chmod" commandline="+x ${fakeroot.bindir}/booc" />
		<exec program="chmod" commandline="+x ${fakeroot.bindir}/booi" />
		<exec program="chmod" commandline="+x ${fakeroot.bindir}/booish" />

		<!-- Copy over documentation -->
		<mkdir dir="${fakeroot.boodocs}"/>

		<copy todir="${fakeroot.boodocs}">
			<fileset basedir="${docs.dir}">
				<include name="*.sxw" />
			</fileset>
		</copy>

		<copy todir="${fakeroot.boodocs}">
			<fileset basedir=".">
				<include name="*.txt" />
			</fileset>
		</copy>

		<!-- Copy over examples -->
		<mkdir dir="${fakeroot.booexamples}"/>

		<copy todir="${fakeroot.booexamples}">
			<fileset basedir="${examples.dir}">
				<include name="**" />
			</fileset>
		</copy>

	</target>

	<target name="install-win32" depends="all">

		<fail unless="${property::exists('mono.prefix')}">
		Please set the property 'mono.prefix' to point to the prefix of your
		mono installation (example: c:\dotnet\mono-1.1.8).
		</fail>

		<copy todir="${path::combine(mono.prefix, 'lib/boo')}">
			<fileset basedir="${build.dir}">
				<include name="*.exe"/>
				<include name="*.rsp"/>
				<include name="*.config"/>
				<include name="*.targets"/>
				<include name="*.Tasks.dll" />
			</fileset>
		</copy>

		<foreach item="File" property="filename">
		<in>
			<items>
				<include name="${build.dir}/Boo.Lang*.dll" />
			</items>
		</in>
		<do>
			<exec program="${path::combine(mono.prefix, 'bin/gacutil.bat')}"
				useruntimeengine="false" workingdir="${build.dir}">
				<arg value="/i" />
				<arg value="${path::get-file-name(filename)}" />
				<arg value="/package" />
				<arg value="boo" />
			</exec>
		</do>
		</foreach>

	</target>

	<target name="uninstall">
		<call target="uninstall-linux" if="${not(platform::is-windows())}"/>
		<call target="uninstall-win32" if="${platform::is-windows()}"/>
	</target>

	<target name="uninstall-linux">
		<!--
		Use pkg-config to find the proper locations for several
		key files for mime detection, etc
		-->

		<property name="sharedmime.prefix" value="${pkg-config::get-variable('shared-mime-info','prefix')}" />
		<property name="fakeroot.sharedmime" value="${fakeroot}/${sharedmime.prefix}" />
		<property name="gsv.prefix" value="${pkg-config::get-variable(gsv.name,'prefix')}" />
		<property name="fakeroot.gsv" value="${fakeroot}/${gsv.prefix}" />

		<foreach item="File" property="filename">
		<in>
			<items>
				<include name="bin/Boo.Lang*.dll" />
			</items>
		</in>
		<do>
			<exec program="gacutil" useruntimeengine="false">
				<arg value="/u" />
				<arg value="${path::get-file-name-without-extension(filename)}" />
				<arg value="/package" />
				<arg value="boo" />
			</exec>
		</do>
		</foreach>

		<delete dir="${fakeroot.boolib}" />
		<delete dir="${fakeroot.boodocs}" />
		<delete dir="${fakeroot.booexamples}" />

		<delete file="${fakeroot.sharedmime}/share/mime-info/boo.keys" />
		<delete file="${fakeroot.sharedmime}/share/mime-info/boo.mime" />
		<delete file="${fakeroot.gsv}/share/${gsv.name}/language-specs/boo.lang" />
		<delete file="${fakeroot.libdir}/pkgconfig/boo.pc" />
		<delete file="${fakeroot.sharedmime}/share/mime/packages/boo-mime-info.xml" />
		<delete file="${fakeroot.bindir}/booi" />
		<delete file="${fakeroot.bindir}/booc" />
		<delete file="${fakeroot.bindir}/booish" />
	</target>

	<target name="uninstall-win32">
		<exec program='${ngen.exe}' if="${file::exists(ngen.exe)}" unless="${skip.ngen}">
			<arg value='/delete' />
			<arg value='Boo.Lang' />
			<arg value='Boo.Lang.Compiler' />
			<arg value='Boo.Lang.Parser' />
			<arg file='${build.dir}/booc.exe' />
		</exec>
	</target>

	<target name="Boo.Lang.Parser" depends="Boo.Lang.Compiler, compile-grammar, generate-errorpatterns">
		<csc target="library"
			output="${build.dir}/Boo.Lang.Parser.dll"
			debug="${debug}"
			optimize="${optimize}"
			define="${csc.define}">
			<sources basedir="src/Boo.Lang.Parser">
				<include name="**/*.cs" />
			</sources>
			<references>
				<include name="${build.dir}/Boo.Lang.dll" />
				<include name="${build.dir}/Boo.Lang.Compiler.dll" />
			</references>
			<nowarn>
				<warning number="618,219,162" />
			</nowarn>
			<arg line="/keyfile:${keyfile.path}" unless="${keyfile.path == ''}" />
		</csc>
	</target>

	<target name="insert-license" depends="core">
		<insertLicense license="notice.txt">
			<fileset basedir="src">
				<include name="**/*.cs" />
				<include name="**/*.boo" />
				<exclude name="Boo.Lang.Parser/antlr/**" />

			</fileset>
			<fileset basedir="examples">
				<include name="**/*.boo" />
			</fileset>
		</insertLicense>
	</target>

	<target name="upload-distro" depends="make-bin-dist">
		<exec program="scp">
			<arg value="-B" />
			<arg file="${boo.distro.name}-bin.zip" />
			<arg file="${boo.distro.name}-src.zip" />
			<arg file="${boo.distro.name}-bin.tar.bz2" />
			<arg file="${boo.distro.name}-src.tar.bz2" />
			<arg file="${boo.distro.name}.tar.gz" />
			<arg value="${distro-user}@beaver.codehaus.org:/home/projects/boo/dist/distributions/" />
		</exec>
	</target>

	<target name="distro">
		<call target="distro-win32" if="${platform::is-windows()}"/>
		<call target="distro-linux" if="${not(platform::is-windows())}"/>
	</target>

	<!-- Deprecated, now that binaries are built for multiple frameworks. -->
	<target name="distro-linux" depends="src-distro">
	</target>

	<!-- meant to be run on Windows with both .net 1.1 and .net 2.0 installed -->
	<target name="distro-win32">
		<fail unless="${nant.platform.win32}">
		Use the make-bin-dist or install targets instead on non-win32 platforms.
		</fail>
		<delete dir="${distrobuild.dir}" if="${directory::exists(distrobuild.dir)}" />
		<mkdir dir="${distrobuild.dir}"/>

		<!-- We call nant externally so we can target multiple frameworks. -->
		<exec program="${nant.location}/NAnt.exe">
			<arg value="rebuild-and-update-bin" />
			<arg value="-D:skip.vs=true" />
		</exec>

		<!-- Here we actually build the zip files. -->
		<call target="src-distro" />
	</target>

	<target name="rebuild-and-update-bin">
		<call target="rebuild" />
		<call target="update-bin" />
	</target>

	<target name="prepare-bin-distro" depends="insert-license">
		<property name="distro.dir" value="${build.dir}/${boo.distro.name}" />

		<delete dir="${distro.dir}" if="${directory::exists(distro.dir)}" />
		<mkdir dir="${distro.dir}" />

		<copy todir="${distro.dir}">
			<fileset>
				<include name="readme.txt" />
				<include name="license.txt" />
				<include name="ast.model.boo" />
				<include name="docs/**/*.boo" />
				<include name="docs/**/*.build" />
				<include name="docs/**/*.sxw" />
				<include name="bin/**/*.dll" />
				<include name="bin/**/*.exe" />
				<include name="bin/**/*.rsp" />
				<include name="bin/**/*.config" />
				<include name="bin/**/*.targets" />

				<include name="extras/**/*.boo" />
				<include name="extras/**/*.cs" />
				<include name="extras/**/*.png" />
				<include name="extras/**/*.ico" />
				<include name="extras/**/*.prjx" />
				<include name="extras/**/*.xml" />
				<include name="extras/**/*.build" />
				<include name="extras/**/*.lang" />
				<include name="extras/**/*.keys" />
				<include name="extras/**/*.mime" />
				<include name="extras/install-gtksourceview-mode" />
				<include name="extras/SharpDevelop/**/*.xshd" />
				<include name="extras/SharpDevelop/**/*.xft" />
				<include name="extras/SharpDevelop/**/*.xpt" />
				<include name="extras/SharpDevelop/**/*.txtres" />
				<include name="extras/SharpDevelop/**/*.addin" />

				<include name="examples/**/*.boo" />
				<include name="examples/**/*.xml" />
				<include name="examples/**/*.aspx" />
				<include name="examples/**/*.build" />
				<include name="examples/**/*.config" />
			</fileset>
		</copy>
	</target>

	<target name="bin-distro" depends="prepare-bin-distro">
		<zip zipfile="${boo.distro.name}-bin.zip" ziplevel="9">
			<fileset basedir="${distro.dir}">
				<include name="**" />
			</fileset>
		</zip>
	</target>

	<target name="prepare-src-distro" depends="bin-distro">
		<copy todir="${distro.dir}">
			<fileset>
				<include name="extras/*.in" />
				<include name="default.build" />
				<include name="notice.txt" />
				<include name="scripts/*.boo" />
				<include name="scripts/Templates/*.cs" />
				<include name="lib/**/*.jar" />
				<include name="configure.in.in" />
				<include name="Makefile.am" />
				<include name="bin/Makefile.am" />
				<include name="extras/Makefile.am" />

				<include name="${keyfile.path}" />
				<include name="src/**/*.cs" />
				<include name="src/**/*.boo" />
				<include name="src/**/*.rsp" />
				<include name="src/**/*.g" />
				<include name="src/**/*.prjx" />
				<include name="src/**/*.cmbx" />
				<include name="src/**/*.targets" />

				<include name="tests/nunit.inc" />
				<include name="tests/test.snk" />
				<include name="tests/**/*.boo" />
				<include name="tests/**/*.cs" />
				<include name="tests/**/*.txt" />
				<include name="tests/**/*.build" />
				<include name="tests/**/*.prjx" />
			</fileset>
		</copy>
	</target>

	<target name="src-distro" depends="prepare-src-distro">
		<zip zipfile="${boo.distro.name}-src.zip" ziplevel="9">
			<fileset basedir="${distro.dir}">
				<include name="**" />
			</fileset>
		</zip>

		<tar destfile="${boo.distro.name}-src.tar.bz2" compression="BZip2">
			<fileset basedir="${build.dir}">
				<include name="${boo.distro.name}/**/*"/>
			</fileset>
		</tar>
	</target>

	<target name="make-bin-dist">
		<copy file="configure.in.in" tofile="configure.in" inputencoding="ASCII">
			<filterchain>
				<replacestring from="VERSION" to="${boo.version}" />
			</filterchain>
		</copy>

		<!-- Needed to keep automake from freaking -->
		<touch file="NEWS"/>
		<touch file="AUTHORS"/>
		<touch file="ChangeLog"/>
		<touch file="README"/>

		<!-- "./autogen.sh", effectively -->
		<exec program="aclocal" useruntimeengine="false" />
		<exec program="autoconf" useruntimeengine="false" />
		<exec program="automake" useruntimeengine="false">
			<arg value="--add-missing" />
		</exec>

		<exec program="./configure" useruntimeengine="false" />

		<exec program="make" useruntimeengine="false">
			<arg value="dist" />
		</exec>

		<exec program="make" useruntimeengine="false">
			<arg value="distclean" />
		</exec>

		<!-- Clean up all the crap autotools spits out everywhere -->
		<delete>
			<fileset>
				<include name="NEWS" />
				<include name="AUTHORS" />
				<include name="ChangeLog" />
				<include name="README" />
				<include name="COPYING" />
				<include name="INSTALL" />
				<include name="**/Makefile.in" />
				<exclude name="lib/**/*.*" />
				<include name="configure" />
				<include name="autom4te.cache/*" />
				<include name="autom4te.cache" />
				<include name="aclocal.m4" />
				<include name="install-sh" />
				<include name="missing" />
				<include name="configure.in" />
			</fileset>
		</delete>
	</target>

	<target name="compile-grammar" depends="init" unless="${skip.antlr}">

		<uptodate property="parser-is-uptodate">
			<sourcefiles basedir="src/Boo.Lang.Parser">
				<include name="boo.g" />
				<include name="booel.g" />
			</sourcefiles>
			<targetfiles basedir="src/Boo.Lang.Parser">
				<include name="BooParserBase.cs" />
				<include name="BooExpressionLexer.cs" />
			</targetfiles>
		</uptodate>

		<if test="${not parser-is-uptodate}">

			<delete>
				<fileset basedir="src/Boo.Lang.Parser">
					<include name="*TokenTypes.*" />
				</fileset>
			</delete>

			<property name="antlr.traceParser" value="-traceParser" if="${antlr.trace}" />
			<property name="antlr.traceParser" value="" unless="${antlr.trace}" />
			<exec program="${java}" failonerror="true">
				<arg value="-cp" />
				<arg file="${antlr.jar}" />
				<arg value="antlr.Tool" />
				<arg value="${antlr.traceParser}" />
				<arg value="-o" />
				<arg value="src/Boo.Lang.Parser/" />
				<arg value="src/Boo.Lang.Parser/boo.g" />
			</exec>

			<exec program="${java}" failonerror="true">
				<arg value="-cp" />
				<arg file="${antlr.jar}" />
				<arg value="antlr.Tool" />
				<arg value="-o" />
				<arg value="src/Boo.Lang.Parser/" />
				<arg value="src/Boo.Lang.Parser/booel.g" />
			</exec>

			<touch file="src/Boo.Lang.Parser/BooParserBase.cs" />
		</if>
	</target>

	<target name="update-vs-env" unless="${skip.vs}">
		<exec program="bin/booi.exe" failonerror="false" useruntimeengine="true">
			<arg value="scripts/update-vs2005-env.boo" />
		</exec>
	</target>

	<target name="generate-ast" depends="init" unless="${skip.ast}">

		<uptodate property="ast-is-uptodate">
			<sourcefiles>
				<include name="ast.model.boo" />
				<include name="scripts/astgen.boo" />
				<include name="scripts/Templates/*.cs" />
			</sourcefiles>
			<targetfiles>
				<include name="src/Boo.Lang.Compiler/Ast/Impl/CompileUnitImpl.cs" />
			</targetfiles>
		</uptodate>

		<if test="${not ast-is-uptodate}">
			<delete dir="src/Boo.Lang.Compiler/Ast/Impl"
					if="${directory::exists('src/Boo.Lang.Compiler/Ast/Impl')}" />
			<mkdir dir="src/Boo.Lang.Compiler/Ast/Impl" />
			<exec program="bin/booi.exe" failonerror="false" useruntimeengine="true">
				<arg value="scripts/astgen.boo" />
			</exec>
		</if>
	</target>

	<target name="generate-errorpatterns" depends="init" unless="${skip.errorpatterns}">
		<uptodate property="errorpatterns-are-uptodate">
			<sourcefiles>
				<include name="scripts/error-patterns.boo" />
				<include name="src/Boo.Lang.Parser/BooParserBase.cs" />
			</sourcefiles>
			<targetfiles>
				<include name="src/Boo.Lang.Parser/GeneratedErrorPatterns.cs" />
			</targetfiles>
		</uptodate>

		<if test="${not file::exists('build/booi.exe')}">
			<echo level="Warning">WARNING: A recent version of Boo is required!</echo>
			<echo level="Warning">Run again Nant (without clean or rebuild) to actually generate the patterns</echo>
			<property name="errorpatterns-are-uptodate" value="True" />
		</if>

		<if test="${not errorpatterns-are-uptodate}">
			<delete file="src/Boo.Lang.Parser/GeneratedErrorPatterns.boo"
					if="${file::exists('src/Boo.Lang.Parser/BooErrorPatterns.boo')}" />
			<!-- TODO: It needs a more recent version of booi than the one in ./bin -->
			<exec program="build/booi.exe" output="src/Boo.Lang.Parser/GeneratedErrorPatterns.cs" failonerror="true" useruntimeengine="true">
				<arg value="scripts/error-patterns.boo" />
			</exec>
		</if>
	</target>

	<target name="update-sharpdevelop" depends="all">
		<copy todir="${sharpdevelop.dir}/AddIns/AddIns/BackendBindings/BooBinding">
			<fileset basedir="${build.dir}">
				<include name="*.dll" />
				<include name="*.exe" />
			</fileset>
		</copy>
	</target>

	<target name="update-assembly-attributes" depends="core">
		<boo>
		import System.IO

		fname = "src/Boo.Lang/Builtins.cs"
		builtins = File.ReadAllText(fname)

		version = Project.Properties["boo.version"]
		newBuiltins = @/new System.Version\(".+"\)/.Replace(builtins, "new System.Version(\"${version}.0\")")
		if builtins != newBuiltins:
			print fname
			File.WriteAllText(fname, newBuiltins)
		</boo>

    		<updateAssemblyVersion
			version="${boo.assembly.version}">
			<fileset basedir="src">
				<include name="**/AssemblyInfo.cs" />
				<include name="**/AssemblyInfo.boo" />
			</fileset>
			<fileset basedir="extras">
				<include name="**/AssemblyInfo.boo" />
			</fileset>
		</updateAssemblyVersion>

		<updateAssemblyVersion
			copyright="(C) 2003-2007 Rodrigo Barreto de Oliveira">
			<fileset basedir="src">
				<include name="**/AssemblyInfo.cs" />
				<include name="**/AssemblyInfo.boo" />
			</fileset>
			<fileset basedir="extras">
				<include name="**/AssemblyInfo.boo" />
				<exclude name="SharpDevelop/**/*.*" />
			</fileset>
		</updateAssemblyVersion>
	</target>

	<target name="rebuild" depends="clean">

		<touch file="ast.model.boo" />
		<touch file="src/Boo.Lang.Parser/boo.g" />
		<touch file="src/Boo.Lang.Parser/booel.g" />
		<mkdir dir="${build.dir}" />
		<call target="all" />
	</target>

	<target name="clean">
		<delete dir="${build.dir}" failonerror="false" />
	</target>

	<target name="init">
		<call target="sign" unless="${nosign}" />
		<!-- This property define is a way to get around the 0.85 NAnt bug regarding signing satelite resource assemblies. -->
		<property name="csc.define" value="${csc.define};IGNOREKEYFILE" unless="${nant-csc-keyfile-bug and not nosign}" />
		<mkdir dir="${build.dir}" />
	</target>

	<target name="makedeb" depends="rebuild">
		<!-- force rebuild to make sure everything's ok and wrappers
		     are sync'ed with current install.prefix
		-->
		<nant buildfile="extras/makedeb.build" />
	</target>


	<target name="Gendarme.Rules.Abstract" depends="core">
		<booc target="library" output="${build.dir}/Gendarme.Rules.Abstract.dll"
		      strict="true" verbose="${verbose}" debug="${debug}">
			<sources basedir="extras/Gendarme.Rules.Abstract">
				<include name="**/*.boo" />
			</sources>
			<references basedir="${gendarme.dir}">
				<include name="Gendarme.Framework.dll" />
				<include name="Mono.Cecil.dll" />
			</references>
		</booc>
	</target>

	<target name="Gendarme.Rules.Boo" depends="Gendarme.Rules.Abstract">
		<booc target="library" output="${build.dir}/Gendarme.Rules.Boo.dll"
		      strict="true" verbose="${verbose}" debug="${debug}">
			<sources basedir="extras/Gendarme.Rules.Boo">
				<include name="**/*.boo" />
			</sources>
			<references basedir="${build.dir}">
				<include name="Gendarme.Rules.Abstract.dll" />
				<include name="${path::combine(gendarme.dir, 'Gendarme.Framework.dll')}" />
			</references>
		</booc>
	</target>

	<target name="gendarme" depends="Gendarme.Rules.Boo">
		<delete file="${build.dir}/gendarme-report.html" failonerror="false" />
		<echo>
		***
		In the event of detected defects, a detailed report will be available at:
		file://${path::combine(path::get-full-path(build.dir), 'gendarme-report.html')}
		***
		</echo>
		<exec program="${path::combine(gendarme.dir,'gendarme.exe')}"
			useruntimeengine="true">
			<arg line="--config extras/rules.xml" />
			<arg line="--html ${build.dir}/gendarme-report.html" />
			<arg line="--set ${gendarme.set}" unless="${gendarme.set == ''}" />
			<arg line="--ignore extras/gendarme.ignore" />

			<arg value="${build.dir}/Boo.Lang.dll" />
			<arg value="${build.dir}/Boo.Lang.Compiler.dll" />
		</exec>
	</target>

</project>