makefile.shade

use assembly="System.Xml.Linq, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
use assembly="System.IO.Compression.FileSystem, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
use import="Environment"
use import="Regex"
use namespace="System.IO"
use namespace="System.Linq"
use namespace="System.Xml.Linq"

var PRODUCT_VERSION = '1.0.0'
var AUTHORS='Microsoft Open Technologies, Inc.'

use-standard-lifecycle
k-standard-goals

var Configuration2='${E("Configuration")}'
var ROOT = '${Directory.GetCurrentDirectory()}'
var SCRIPTS_DIR = '${Path.Combine(ROOT, "scripts")}'
var ARTIFACTS_DIR = '${Path.Combine(ROOT, "artifacts")}'
var BUILD_DIR2 = '${Path.Combine(ROOT, "artifacts", "build")}'
var NUSPEC_ROOT = '${Path.Combine(ROOT, "nuspec")}'
var PACKAGES_DIR = '${Path.Combine(ROOT, "packages")}'
var TEST_RESULTS = '${Path.Combine(ROOT, "artifacts", "TestResults")}'
var SAMPLES_DIR = '${Path.Combine(ROOT, "samples")}'
var FULL_VERSION = '${PRODUCT_VERSION + "-" + E("DNX_BUILD_VERSION")}'
var CORECLR_TARGET_PATH = '${Path.Combine(BUILD_DIR2, "CoreCLR")}'
var RUNTIME_NAME_PREFIX = 'dnx-'
var RUNTIME_MONO_NAME = '${RUNTIME_NAME_PREFIX + "mono"}'
var RUNTIME_CLR_WIN_x86_NAME = '${RUNTIME_NAME_PREFIX + "clr-win-x86"}'
var RUNTIME_CLR_WIN_x64_NAME = '${RUNTIME_NAME_PREFIX + "clr-win-x64"}'
var RUNTIME_CORECLR_WIN_x86_NAME = '${RUNTIME_NAME_PREFIX + "coreclr-win-x86"}'
var RUNTIME_CORECLR_WIN_x64_NAME = '${RUNTIME_NAME_PREFIX + "coreclr-win-x64"}'
var RUNTIME_MONO_BIN = '${Path.Combine(BUILD_DIR2, RUNTIME_MONO_NAME, "bin")}'
var RUNTIME_CLR_WIN_x86_BIN = '${Path.Combine(BUILD_DIR2, RUNTIME_CLR_WIN_x86_NAME, "bin")}'
var RUNTIME_CLR_WIN_x64_BIN = '${Path.Combine(BUILD_DIR2, RUNTIME_CLR_WIN_x64_NAME, "bin")}'
var RUNTIME_CORECLR_WIN_x86_BIN = '${Path.Combine(BUILD_DIR2, RUNTIME_CORECLR_WIN_x86_NAME, "bin")}'
var RUNTIME_CORECLR_WIN_x64_BIN = '${Path.Combine(BUILD_DIR2, RUNTIME_CORECLR_WIN_x64_NAME, "bin")}'
var RUNTIME_CLR_TARGETS = '${new [] {RUNTIME_MONO_BIN, RUNTIME_CLR_WIN_x86_BIN, RUNTIME_CLR_WIN_x64_BIN}}'
var RUNTIME_CORECLR_TARGETS = '${new [] {RUNTIME_CORECLR_WIN_x86_BIN, RUNTIME_CORECLR_WIN_x64_BIN}}'
var ALL_TARGETS = '${RUNTIME_CLR_TARGETS.Concat(RUNTIME_CORECLR_TARGETS)}'
var NEW_RUNTIME = '${E("NEW_RUNTIME") == "1"}'
var RUNTIME_COMMON_NAME = 'DNX'
var BOOTSTRAPPER_EXE_NAME = 'dnx'
var BOOTSTRAPPER_CLR_NAME = 'dnx.clr'
var BOOTSTRAPPER_CORECLR_NAME = 'dnx.coreclr'
var BOOTSTRAPPER_CLR_MANAGED_NAME = '${BOOTSTRAPPER_CLR_NAME + ".managed"}'
var BOOTSTRAPPER_CORECLR_MANAGED_NAME = '${BOOTSTRAPPER_CORECLR_NAME + ".managed"}'
var BOOTSTRAPPER_MONO_MANAGED_NAME = 'dnx.mono.managed'
var BOOTSTRAPPER_HOST_NAME = 'dnx.host'

var PROGRAM_FILES_X86 = '${Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86)}'
var MSBUILD = '${Path.Combine(PROGRAM_FILES_X86, "MSBuild", "14.0", "Bin", "MSBuild.exe")}'

var MANAGED_PROJECTS = '${FindAllProjects(
    BOOTSTRAPPER_HOST_NAME,
    "Microsoft.Framework.ApplicationHost",
    "Microsoft.Framework.ApplicationHost2",
    "Microsoft.Framework.CommandLineUtils",
    "Microsoft.Framework.DesignTimeHost",
    "Microsoft.Framework.DesignTimeHost.Interfaces",
    "Microsoft.Framework.PackageManager",
    "Microsoft.Framework.Project",
    "Microsoft.Framework.Runtime",
    "Microsoft.Framework.Runtime.Caching",
    "Microsoft.Framework.Runtime.Interfaces",
    "Microsoft.Framework.Runtime.Compilation.DesignTime",
    "Microsoft.Framework.Runtime.Common",
    "Microsoft.Framework.Runtime.Loader",
    "Microsoft.Framework.Runtime.Roslyn",
    "Microsoft.Framework.Runtime.Roslyn.Interfaces",
    "Microsoft.Framework.Runtime.Roslyn.Common")}'

var WIN_NATIVE_PROJECTS = '${FindAllProjects(
    BOOTSTRAPPER_EXE_NAME,
    BOOTSTRAPPER_CLR_NAME,
    BOOTSTRAPPER_CORECLR_NAME)}'

var WIN_MANAGED_PROJECTS = '${FindAllProjects(
    BOOTSTRAPPER_CLR_MANAGED_NAME,
    BOOTSTRAPPER_CORECLR_MANAGED_NAME)}'

var MONO_NATIVE_PROJECTS = '${FindAllProjects()}'

var MONO_MANAGED_PROJECTS = '${FindAllProjects(BOOTSTRAPPER_MONO_MANAGED_NAME)}'

var RC_FILES = '${FindAllFiles("Resource.rc", BOOTSTRAPPER_EXE_NAME, BOOTSTRAPPER_CLR_NAME, BOOTSTRAPPER_CORECLR_NAME)}'

-//Replace repo-initialize with a less greedy restore
#repo-initialize target='initialize'
	git gitCommand="submodule update --init"	
	for each='var projectFile in Files.Include("src/*/project.json")'
		exec program='cmd' commandline='/C dnu restore' if='!IsMono' workingdir="${Path.GetDirectoryName(projectFile)}"
		exec program='dnu' commandline='restore' if='IsMono' workingdir="${Path.GetDirectoryName(projectFile)}"
	for each='var projectFile in Files.Include("test/*/project.json")'
		exec program='cmd' commandline='/C dnu restore' if='!IsMono' workingdir="${Path.GetDirectoryName(projectFile)}"
		exec program='dnu' commandline='restore' if='IsMono' workingdir="${Path.GetDirectoryName(projectFile)}"
	for each='var projectFile in Files.Include("samples/*/project.json")'
		exec program='cmd' commandline='/C dnu restore' if='!IsMono' workingdir="${Path.GetDirectoryName(projectFile)}"
		exec program='dnu' commandline='restore' if='IsMono' workingdir="${Path.GetDirectoryName(projectFile)}"

#build-compile target='compile'

#native-compile target='compile' if='!IsMono'

#build-crossplatfrom-projects target='build-compile'
    @{ var BUILD_DIR = BUILD_DIR2; }
    kpm-pack each='var projectFile in MANAGED_PROJECTS' configuration='${Configuration2}'
    @{
        foreach (var nupkg in Files.Include(Path.Combine(BUILD_DIR, "*/*.nupkg"))) 
        {
            File.Copy(nupkg, Path.Combine(BUILD_DIR, Path.GetFileName(nupkg)), true);
        }
    }

#build-winplatform-projects target='build-compile' if='!IsMono'
    @{ var BUILD_DIR = BUILD_DIR2; }
    kpm-pack each='var projectFile in WIN_MANAGED_PROJECTS' configuration='${Configuration2}'
    @{
        foreach (var nupkg in Files.Include(Path.Combine(BUILD_DIR, "*/*.nupkg"))) 
        {
            File.Copy(nupkg, Path.Combine(BUILD_DIR, Path.GetFileName(nupkg)), true);
        }
    }

#update-rc-files if='!IsMono'
    if condition='IsTeamCity'
        for each='var rcfile in RC_FILES'
            @{
                var digitVer = PRODUCT_VERSION.Replace(".", ",") + ",0";

                var productVersionStructMatcher = @"PRODUCTVERSION \d+,\d+,\d+,\d+";
                var productVersionValueMatcher = @"VALUE ""ProductVersion"", ""[^""]+""";
                var productVersionStruct = "PRODUCTVERSION " + digitVer;
                var productVersionValue = "VALUE \"ProductVersion\", \"" + FULL_VERSION + "\"";

                var fileVersionStructMatcher = @"FILEVERSION \d+,\d+,\d+,\d+";
                var fileVersionValueMatcher = @"VALUE ""FileVersion"", ""[^""]+""";
                var fileVersionStruct = "FILEVERSION " + digitVer;
                var fileVersionValue = "VALUE \"FileVersion\", \"" + FULL_VERSION + "\"";
            }
            update-file updateFile="${rcfile}" @{
                updateText = RegexReplace(updateText, productVersionStructMatcher, productVersionStruct);
                updateText = RegexReplace(updateText, productVersionValueMatcher, productVersionValue);
                updateText = RegexReplace(updateText, fileVersionStructMatcher, fileVersionStruct);
                updateText = RegexReplace(updateText, fileVersionValueMatcher, fileVersionValue);
            }

#build-native-bootstrapper .update-rc-files target='native-compile' if='!IsMono'
    var bootstrapperProj = '${Path.Combine(ROOT, "src", BOOTSTRAPPER_EXE_NAME, BOOTSTRAPPER_EXE_NAME + ".vcxproj")}'
    @{
        if (!IsMsbuildInstalled(MSBUILD))
        {
            Environment.Exit(1);
        }
        else
        {
            var environmentRuntimeTargetOS = Environment.GetEnvironmentVariable("RUNTIME_TARGET_OS");
            var configRuntimeTargetOS = "";
        
            Exec(MSBUILD, bootstrapperProj + " /p:Configuration=" + Configuration2 + ";Platform=Win32;TargetFramework=dnx451;RuntimeType=CLR");
            Exec(MSBUILD, bootstrapperProj + " /p:Configuration=" + Configuration2 + ";Platform=x64;TargetFramework=dnx451;RuntimeType=CLR");

            if (environmentRuntimeTargetOS == "WIN7_PLUS_CORESYSTEM")
            {
                configRuntimeTargetOS = ";RuntimeTargetOS=WIN7_PLUS_CORESYSTEM";
            }
            
            Exec(MSBUILD, bootstrapperProj + " /p:Configuration=" + Configuration2 + ";Platform=Win32;TargetFramework=dnxcore50;RuntimeType=CORECLR_WIN" + configRuntimeTargetOS);
            Exec(MSBUILD, bootstrapperProj + " /p:Configuration=" + Configuration2 + ";Platform=x64;TargetFramework=dnxcore50;RuntimeType=CORECLR_WIN" + configRuntimeTargetOS);
        }
    }

  directory delete='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_EXE_NAME)}'
  copy sourceDir='${Path.Combine(ROOT, "src", BOOTSTRAPPER_EXE_NAME)}' include='bin/**/' outputDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_EXE_NAME)}' overwrite='${true}'

#build-native-bootstrapper-core45 .copy-coreclr .update-tpa target='native-compile' if='!IsMono'
    var bootstrapperCore45Proj = '${Path.Combine(ROOT, "src", BOOTSTRAPPER_CORECLR_NAME, BOOTSTRAPPER_CORECLR_NAME + ".vcxproj")}'
    @{
        if (!IsMsbuildInstalled(MSBUILD))
        {
            Environment.Exit(1);
        }
        else
        {
            var environmentRuntimeTargetOS = Environment.GetEnvironmentVariable("RUNTIME_TARGET_OS");
            var configRuntimeTargetOS = "";
        
            if (environmentRuntimeTargetOS == "WIN7_PLUS_CORESYSTEM")
            {
                configRuntimeTargetOS = ";RuntimeTargetOS=WIN7_PLUS_CORESYSTEM";
            }
            
            Exec(MSBUILD, bootstrapperCore45Proj + " /p:Configuration=" + Configuration2 + ";Platform=Win32" + configRuntimeTargetOS);
            Exec(MSBUILD, bootstrapperCore45Proj + " /p:Configuration=" + Configuration2 + ";Platform=x64" + configRuntimeTargetOS);
        }
    }

  directory delete='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CORECLR_NAME)}'
  copy sourceDir='${Path.Combine(ROOT, "src", BOOTSTRAPPER_CORECLR_NAME)}' include='bin/**/' outputDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CORECLR_NAME)}' overwrite='${true}'

#build-native-bootstrapper-net45 target='native-compile' if='!IsMono'
    var bootstrapperNet45Proj ='${Path.Combine(ROOT, "src", BOOTSTRAPPER_CLR_NAME, BOOTSTRAPPER_CLR_NAME + ".vcxproj")}'
    @{
        if (!IsMsbuildInstalled(MSBUILD))
        {
            Environment.Exit(1);
        }
        else
        {
            Exec(MSBUILD, bootstrapperNet45Proj + " /p:Configuration=" + Configuration2 + ";Platform=Win32");
            Exec(MSBUILD, bootstrapperNet45Proj + " /p:Configuration=" + Configuration2 + ";Platform=x64");
        }
    }
    directory delete='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CLR_NAME)}'
    copy sourceDir='${Path.Combine(ROOT, "src", BOOTSTRAPPER_CLR_NAME)}' include='bin/**/' outputDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CLR_NAME)}' overwrite='${true}' 

#build-mono-entrypoint target='build-compile'
    var monoManagedOutpath='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_MONO_MANAGED_NAME)}'
    directory create='${monoManagedOutpath}'
    @{
        var bootstrapperAssembly = Path.Combine(BUILD_DIR2, BOOTSTRAPPER_HOST_NAME, "dnx451", BOOTSTRAPPER_HOST_NAME + ".dll");

        var sourceFiles = new string[] 
        {
            Path.Combine("src", BOOTSTRAPPER_MONO_MANAGED_NAME, "EntryPoint.cs"),
            Path.Combine("src", "Microsoft.Framework.CommandLineUtils", "CommandLine", "CommandArgument.cs"),
            Path.Combine("src", "Microsoft.Framework.CommandLineUtils", "CommandLine", "CommandLineApplication.cs"), 
            Path.Combine("src", "Microsoft.Framework.CommandLineUtils", "CommandLine", "CommandOption.cs"), 
            Path.Combine("src", "Microsoft.Framework.CommandLineUtils", "CommandLine", "CommandOptionType.cs"),
            Path.Combine("src", "Microsoft.Framework.Runtime.Common", "Impl", "EnvironmentNames.cs"),
            Path.Combine("src", "Microsoft.Framework.Runtime.Common", "Impl", "Constants.cs")
        };

        var arguments = string.Format(
            @"/target:exe /nologo /unsafe /out:""{0}"" /r:""{1}"" /define:DNX451 {2}",
            Path.Combine(monoManagedOutpath, BOOTSTRAPPER_MONO_MANAGED_NAME + ".dll"),
            bootstrapperAssembly,
            string.Join(" ", sourceFiles));

        var compiler = IsMono ? "mcs" : Path.Combine(Environment.GetEnvironmentVariable("WINDIR"), "Microsoft.NET", "Framework", "v4.0.30319", "csc.exe");

        Log.Info("Using compiler :" + compiler + " for Mono Entry point executor");

        Exec(compiler, arguments);
    }

#package-runtime .clean-sdk-dir .copy-bits .tweak-scripts .copy-coreclr .copy-required-dependencies .nuget-pack-runtime target='package'

#rebuild-package .build-compile .build-mono-entrypoint .native-compile .package-runtime .xunit-test

#xunit-test target='test' if='Directory.Exists("test")'
    k-test each='var projectFile in Files.Include("test/**/project.json")' if='NEW_RUNTIME'

#ensure-latest-package
    @{
        // We need to re-run the build using the current output

        var nupkgPath = Files.Include(Path.Combine(BUILD_DIR2, RUNTIME_CLR_WIN_x86_NAME + ".*.nupkg")).Single();
        Log.Info("Unpacking " + nupkgPath);
        if (Directory.Exists(Path.Combine(PACKAGES_DIR, RUNTIME_COMMON_NAME))) {
            Directory.Delete(Path.Combine(PACKAGES_DIR, RUNTIME_COMMON_NAME), recursive:true);
        }

        Directory.CreateDirectory(Path.Combine(PACKAGES_DIR, RUNTIME_COMMON_NAME));

        System.IO.Compression.ZipFile.ExtractToDirectory(
            Path.Combine(nupkgPath),
            Path.Combine(PACKAGES_DIR, RUNTIME_COMMON_NAME));

        // Delete the build dir
        Directory.Delete(BUILD_DIR2, recursive: true);

        var envPath = Environment.GetEnvironmentVariable("PATH");
        try
        {
            Log.Info("Adding PATH " + Path.Combine(PACKAGES_DIR, RUNTIME_COMMON_NAME, "bin"));
            Environment.SetEnvironmentVariable("PATH", Path.Combine(PACKAGES_DIR, RUNTIME_COMMON_NAME, "bin") + ";" + envPath);
            Environment.SetEnvironmentVariable("NEW_RUNTIME", "1");
            Log.Info("Rebuilding target default");

            // TODO REMOVE after bootstrapping: We need to restore again because the location changes
            Exec("build.cmd", "initialize");
            Exec("build.cmd", "rebuild-package");
        }
        finally
        {
            Environment.SetEnvironmentVariable("PATH", envPath);
            Environment.SetEnvironmentVariable("NEW_RUNTIME", null);
        }
    }

#verify-package .ensure-latest-package target='verify'

#clean-sdk-dir
    directory each='var delete in ALL_TARGETS'
    directory each='var create in ALL_TARGETS'

#copy-bits
    var x86Target="x86"
    var x64Target="amd64"

    -// Runtime for mono
    copy sourceDir='${SCRIPTS_DIR}' include='*.sh' outputDir='${RUNTIME_MONO_BIN}' overwrite='${true}'
    copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_MONO_MANAGED_NAME)}' outputDir='${RUNTIME_MONO_BIN}' include='*.dll' overwrite='${true}'

    @{
        // Rename all .sh files to remove the sh
        foreach (var shFile in Files.Include(Path.Combine(RUNTIME_MONO_BIN, "*.sh")))
        {
            var targetShFile = Path.Combine(Path.GetDirectoryName(shFile), 
                                            Path.GetFileNameWithoutExtension(shFile));
            if (File.Exists(targetShFile))
            {
                File.Delete(targetShFile);
            }

            // Make sure new lines are \n (\r\n messes up the bash script)
            var script = File.ReadAllText(shFile).Replace('\r\n', '\n');
            File.Move(shFile, targetShFile);
            File.WriteAllText(targetShFile, script);
        }
    }

    test if='!IsMono'
        -// Runtime for clr-win-x86
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_EXE_NAME, "bin", "Win32", Configuration2, "dnx451")}' outputDir='${RUNTIME_CLR_WIN_x86_BIN}' include='*.exe' overwrite='${true}'
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CLR_NAME, "bin", "Win32", Configuration2)}' outputDir='${RUNTIME_CLR_WIN_x86_BIN}' include='*.dll' overwrite='${true}'
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CLR_NAME, "bin", "Win32", Configuration2)}' outputDir='${RUNTIME_CLR_WIN_x86_BIN}' include='*.pdb' overwrite='${true}'
        copy sourceDir='${Path.Combine(ROOT, "src", BOOTSTRAPPER_CLR_MANAGED_NAME)}' outputDir='${RUNTIME_CLR_WIN_x86_BIN}' include='*.config' overwrite='${true}'

        -// Runtime for clr-win-x64
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_EXE_NAME, "bin", "x64", Configuration2, "dnx451")}' outputDir='${RUNTIME_CLR_WIN_x64_BIN}' include='*.exe' overwrite='${true}'
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CLR_NAME, "bin", "x64", Configuration2)}' outputDir='${RUNTIME_CLR_WIN_x64_BIN}' include='*.dll' overwrite='${true}'
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CLR_NAME, "bin", "x64", Configuration2)}' outputDir='${RUNTIME_CLR_WIN_x64_BIN}' include='*.pdb' overwrite='${true}'
        copy sourceDir='${Path.Combine(ROOT, "src", BOOTSTRAPPER_CLR_MANAGED_NAME)}' outputDir='${RUNTIME_CLR_WIN_x64_BIN}' include='*.config' overwrite='${true}'

        -// Runtime for coreclr-win-x86
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_EXE_NAME, "bin", "Win32", Configuration2, "dnxcore50")}' outputDir='${RUNTIME_CORECLR_WIN_x86_BIN}' include='*.exe' overwrite='${true}'
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CORECLR_NAME, "bin", "Win32", Configuration2)}' outputDir='${RUNTIME_CORECLR_WIN_x86_BIN}' include='*.dll' overwrite='${true}'
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CORECLR_NAME, "bin", "Win32", Configuration2)}' outputDir='${RUNTIME_CORECLR_WIN_x86_BIN}' include='*.pdb' overwrite='${true}'

        -// Runtime for coreclr-win-x64
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_EXE_NAME, "bin", "x64", Configuration2, "dnxcore50")}' outputDir='${RUNTIME_CORECLR_WIN_x64_BIN}' include='*.exe' overwrite='${true}'
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CORECLR_NAME, "bin", "x64", Configuration2)}' outputDir='${RUNTIME_CORECLR_WIN_x64_BIN}' include='*.dll' overwrite='${true}'
        copy sourceDir='${Path.Combine(BUILD_DIR2, BOOTSTRAPPER_CORECLR_NAME, "bin", "x64", Configuration2)}' outputDir='${RUNTIME_CORECLR_WIN_x64_BIN}' include='*.pdb' overwrite='${true}'

        copy sourceDir='${SCRIPTS_DIR}' include='*.cmd' overwrite='${true}' each='var outputDir in new[]{ RUNTIME_CLR_WIN_x86_BIN, RUNTIME_CLR_WIN_x64_BIN, RUNTIME_CORECLR_WIN_x86_BIN, RUNTIME_CORECLR_WIN_x64_BIN }'

    @{
        var hostAspNetCore50 = Path.Combine(BUILD_DIR2, "*", "dnxcore50", "**.*");
        var hostnet45 = Path.Combine(BUILD_DIR2, "*", "dnx451", "**.*");
        
        var binPackages = new[] { "Microsoft.Framework.Runtime.Interfaces" };

        var libPackages = new[] { "Microsoft.Framework.Project",
                                  "Microsoft.Framework.PackageManager", 
                                  "Microsoft.Framework.DesignTimeHost" };

        var sharedSourceAssemblies = new [] { 
            Path.Combine(BUILD_DIR2, "Microsoft.Framework.CommandLineUtils/**/*.*"), 
            Path.Combine(BUILD_DIR2, "Microsoft.Framework.Runtime.Common/**/*.*"),
        };
        
        foreach(var file in Files.Include(hostAspNetCore50).Exclude(sharedSourceAssemblies))
        {
            foreach(var aspNetCore50Target in RUNTIME_CORECLR_TARGETS)
            {
                string dest = Path.Combine(aspNetCore50Target, Path.GetFileName(file));
                File.Copy(file, dest, true);
            }
        }
        
        foreach(var file in Files.Include(hostnet45).Exclude(sharedSourceAssemblies))
        {
            foreach(var net45Target in RUNTIME_CLR_TARGETS)
            {
                string dest = Path.Combine(net45Target, Path.GetFileName(file));
                File.Copy(file, dest, true);
            }
        }

        // Clean up net45.managed from mono (it's never used)
        File.Delete(Path.Combine(RUNTIME_MONO_BIN, BOOTSTRAPPER_CLR_MANAGED_NAME + ".dll"));

        // Remove k-crossgen.cmd from the net45 build
        foreach (var net45Target in RUNTIME_CLR_TARGETS)
        {
            var crossgen = Path.Combine(net45Target, "k-crossgen.cmd");
            if(File.Exists(crossgen))
            {
                File.Delete(crossgen);
                Log.Info("Deleting crossgen from " + crossgen);
            }
        }

        Action<string, string, string> move = (binFolder, name, extension) =>
        {
            var libPath = Path.Combine(binFolder, "lib", name);
            var source = Path.Combine(binFolder, name + extension);
            var target = Path.Combine(libPath, name + extension);
            
            if (File.Exists(source))
            {
                if (File.Exists(target))
                {
                    File.Delete(target);
                }
                
                Directory.CreateDirectory(libPath);
                File.Move(source, target);

                Log.Info("Moving " + name + " to " + target);
            }
            else
            {
                Log.Warn(name + " does not exist in " + binFolder);
            }
        };
        
        // Move some packages into the lib/ folder
        foreach (var libPackage in libPackages)
        {
            foreach(var binFolder in ALL_TARGETS)
            {
                move(binFolder, libPackage, ".dll");
                move(binFolder, libPackage, ".pdb");
            }
        }
    }

#tweak-scripts
    @{
        foreach(var targetDir in new[] { RUNTIME_CLR_WIN_x86_BIN, RUNTIME_CLR_WIN_x64_BIN, RUNTIME_CORECLR_WIN_x86_BIN, RUNTIME_CORECLR_WIN_x64_BIN })
        {
            foreach(var file in Files.Include(Path.Combine(targetDir, "*.cmd")))
            {
                var script = File.ReadAllText(file);

                script = Regex.Replace(script, @"REM \<dev\>(.*?)REM \<\/dev\>(\s*)", @"", RegexOptions.Singleline);

                File.WriteAllText(file, script);
            }
        }
    }

#copy-coreclr
    @{
        var extras = "-pre -nocache";
        var coreCLRPackageSource = E("CORECLR_PACKAGE_SOURCE");
        if (!string.IsNullOrEmpty(coreCLRPackageSource))
        {
            extras += " -source " + coreCLRPackageSource;
        }
    }

    nuget-install package='CoreCLR' outputDir='packages' extra='${extras}' once='CoreCLR' nugetPath='.nuget/nuget.exe'

    var CoreCLR_DIR='${""}'
    @{
        Func<string, long> getVersion = version => {
        var dash = version.LastIndexOf('-');

            if(dash != -1)
            {
                var lastToken = version.Substring(dash + 1);

                if(lastToken.StartsWith("t"))
                {
                    return Int64.Parse(lastToken.Substring(1));
                }

                return Int64.Parse(lastToken);
            }
            return Int64.MaxValue;
        };

        string packagesDir = Path.Combine(Directory.GetCurrentDirectory(), "packages");
        CoreCLR_DIR = Directory.EnumerateDirectories(packagesDir, "CoreCLR*")
                                .OrderByDescending(getVersion)
                                .First();
                                      
        Log.Info("Using " + CoreCLR_DIR);
    }
    
    -// Copy to target
    copy sourceDir='${Path.Combine(CoreCLR_DIR, "Runtime")}' outputDir='${Path.Combine(CORECLR_TARGET_PATH, "Runtime")}' overwrite='${true}'

#copy-required-dependencies
     @{
        var targets = new[]
        {
            new { TargetFolder = RUNTIME_CLR_WIN_x86_BIN,        Framework = "dnx451",     Arch = "x86",   Mono = false},
            new { TargetFolder = RUNTIME_CLR_WIN_x64_BIN,        Framework = "dnx451",     Arch = "amd64", Mono = false},
            new { TargetFolder = RUNTIME_MONO_BIN,               Framework = "dnx451",     Arch = "x86",   Mono = true},
            new { TargetFolder = RUNTIME_CORECLR_WIN_x86_BIN,    Framework = "dnxcore50", Arch = "x86",   Mono = false},
            new { TargetFolder = RUNTIME_CORECLR_WIN_x64_BIN,    Framework = "dnxcore50", Arch = "amd64", Mono = false},
        };

        var runtimeProjects = new[]
        {
            "Microsoft.Framework.Runtime.Roslyn",
            "Microsoft.Framework.ApplicationHost",
            "Microsoft.Framework.Runtime.Compilation.DesignTime",
            BOOTSTRAPPER_HOST_NAME, 
            BOOTSTRAPPER_CORECLR_MANAGED_NAME 
        };

        var sdkProjects = new[]
        {
            "Microsoft.Framework.DesignTimeHost",
            "Microsoft.Framework.PackageManager",
            "Microsoft.Framework.Project"
        };

        foreach (var target in targets)
        {
            if (IsMono && !target.Mono)
            {
                continue;
            }
            var coreclrFolder = Path.Combine(CORECLR_TARGET_PATH, "Runtime", target.Arch);

            // parse and copy runtime assemblies
            var runtimeAssemblies = new HashSet<string>();
            foreach (var project in runtimeProjects)
            {
                if (project == BOOTSTRAPPER_CORECLR_MANAGED_NAME && target.Framework == "dnx451")
                    continue;

                var projectFolder = Path.Combine(ROOT, "src", project);
                var projectAssemblies = ListDependencyAssemblies(projectFolder, target.Framework, target.Framework == "dnxcore50" ? coreclrFolder : null);

                try
                {
                    foreach (var file in projectAssemblies)
                    {
                        if (runtimeAssemblies.Add(file))
                        {
                            var targetFilePath = Path.Combine(target.TargetFolder, Path.GetFileName(file));
                            Log.Info("Copying " + file + " to " + targetFilePath);
                            File.Copy(file, targetFilePath, true);
                        }
                    }
                }
                catch (Exception ex)
                {
                    throw new InvalidOperationException(string.Format("Fail to copy runtime assemblies [{0}]", ex.Message));
                }
            }

            // parse and copy lib assemblies
            foreach (var project in sdkProjects)
            {
                var projectFolder = Path.Combine(ROOT, "src", project);
                var projectAssemblies = ListDependencyAssemblies(projectFolder, target.Framework, target.Framework == "dnxcore50" ? coreclrFolder : null);

                projectAssemblies.ExceptWith(runtimeAssemblies);

                var targetLibDir = Path.Combine(target.TargetFolder, "lib", project);
                if (Directory.Exists(targetLibDir))
                {
                    foreach (var file in projectAssemblies)
                    {
                        var targetFilePath = Path.Combine(targetLibDir, Path.GetFileName(file));
                        Log.Info("Copying " + file + " to " + targetFilePath);
                        File.Copy(file, targetFilePath, true);
                    }
                }
            }

            // copy required CoreCLR assemblies
            if (target.Framework == "dnxcore50")
            {
                var assemblyExceptions = new[] { "System.Private.DataContractSerialization.dll", "System.Private.Networking.dll" };
				
                foreach (var file in Directory.GetFiles(coreclrFolder).Where(filePath => !Path.GetFileName(filePath).StartsWith("System") || assemblyExceptions.Contains(Path.GetFileName(filePath), StringComparer.Ordinal)))
                {
                    var targetFilePath = Path.Combine(target.TargetFolder, Path.GetFileName(file));
                    Log.Info("Copying " + file + " to " + targetFilePath);
                    File.Copy(file, targetFilePath, true);
                }
            }

            // copy runtime interfaces
            var mfriPath = Path.Combine(BUILD_DIR2, "Microsoft.Framework.Runtime.Interfaces", target.Framework, "Microsoft.Framework.Runtime.Interfaces.dll");
            var mfriPdbPath = Path.Combine(BUILD_DIR2, "Microsoft.Framework.Runtime.Interfaces", target.Framework, "Microsoft.Framework.Runtime.Interfaces.pdb");

            if(File.Exists(mfriPath))
            {
                File.Copy(mfriPath, Path.Combine(target.TargetFolder, "Microsoft.Framework.Runtime.Interfaces.dll"), true);
            }
            if(File.Exists(mfriPdbPath))
            {
                File.Copy(mfriPdbPath, Path.Combine(target.TargetFolder, "Microsoft.Framework.Runtime.Interfaces.pdb"), true);
            }
        }
    }

#nuget-pack-runtime
    @{
        UpdateAllNuspecs(NUSPEC_ROOT, BUILD_DIR2);
    }
    nuget-pack packageVersion='${FULL_VERSION}' outputDir='${BUILD_DIR2}' extra='-NoPackageAnalysis -Properties RuntimeNamePrefix=${RUNTIME_NAME_PREFIX}' nugetPath='.nuget/nuget.exe' each='var nuspecFile in Files.Include(Path.Combine(BUILD_DIR2, "*.nuspec"))'

#dev-install
    @{
        InstallDevRuntime(RUNTIME_MONO_BIN);
        
        if (!IsMono)
        {
            InstallDevRuntime(RUNTIME_CLR_WIN_x86_BIN);
            InstallDevRuntime(RUNTIME_CLR_WIN_x64_BIN);
            InstallDevRuntime(RUNTIME_CORECLR_WIN_x86_BIN);
            InstallDevRuntime(RUNTIME_CORECLR_WIN_x64_BIN);
        }
    }
    
#install-runtime target='install'
    var matchVersion=''
    for each='var name in new[]{ RUNTIME_CLR_WIN_x86_NAME, RUNTIME_CORECLR_WIN_x86_NAME, RUNTIME_CLR_WIN_x64_NAME, RUNTIME_CORECLR_WIN_x64_NAME }'
        for each='var runtime in Files.Include(Path.Combine(BUILD_DIR2, name + ".*.nupkg"))'
            exec program='cmd' commandline='/C dnvm install ${runtime}' if='!IsMono'
            var parts='${Path.GetFileNameWithoutExtension(runtime).Split(".".ToArray(), 2)}'
            set matchVersion='${parts[1]}' if='matchVersion == ""'

    exec program='cmd' commandline='/C dnvm alias build ${matchVersion}' if='!IsMono && matchVersion != ""' 
    exec program='cmd' commandline='/C start cmd /K dnvm use build' if='!IsMono && matchVersion != ""' 

#update-tpa
    @{
        var envTrace = Environment.GetEnvironmentVariable("DNX_TRACE");

        try
        {
            var dotnetcoreclrDepFile = Path.Combine(BUILD_DIR2, "dotnetcoreclr-dependencies.txt");
            var tpacppFile = Path.Combine(ROOT, "src", BOOTSTRAPPER_CORECLR_NAME, "tpa.cpp");
            var tpacppFileUnix = Path.Combine(ROOT, "src", BOOTSTRAPPER_CORECLR_NAME + ".unix", "tpa.cpp");
            Environment.SetEnvironmentVariable("DNX_TRACE", "0");
            Exec("cmd", string.Format(@"/C dnu list {0} --assemblies --runtime {1} > {2}",
                Path.Combine(ROOT, "src", BOOTSTRAPPER_HOST_NAME),
                Path.Combine(CORECLR_TARGET_PATH, "Runtime", "x86"),
                dotnetcoreclrDepFile ));

            var tpaProjects = new[] {
                BOOTSTRAPPER_HOST_NAME,
                BOOTSTRAPPER_CORECLR_MANAGED_NAME,
                "Microsoft.Framework.Runtime.Interfaces",
                "Microsoft.Framework.Runtime.Loader"
            };

            UpdateTpa(dotnetcoreclrDepFile, tpaProjects, tpacppFile);
            UpdateTpa(dotnetcoreclrDepFile, tpaProjects, tpacppFileUnix);
        }
        finally
        {
            Environment.SetEnvironmentVariable("DNX_TRACE", envTrace);
        }
    }
  
macro name='NuGetInstall' Package='string' OutputDir='string' Extra='string'
    nuget-install package='${Package}' outputDir='${OutputDir}' extra='${Extra}' nugetPath='.nuget/nuget.exe'

functions @{

    private static readonly string _defaultLocalRuntimeHomeDir = ".dnx";
    private static readonly string _packagesSubDir = "packages";
    private static readonly string _runtimesSubDir = "runtimes";

    int ExecuteAndRedirectOutput(string command, string argument, string outputFile)
    {
        var procStartInfo = new ProcessStartInfo 
        {
            FileName = command, 
            Arguments = argument, 
            WorkingDirectory = Directory.GetCurrentDirectory(),
            UseShellExecute = false
        };
        procStartInfo.EnvironmentVariables["DNX_TRACE"] = "0";
        procStartInfo.RedirectStandardOutput = true;

        var process = Process.Start(procStartInfo);
        var content = process.StandardOutput.ReadToEnd();
        process.WaitForExit();

        File.WriteAllText(outputFile, content);

        return process.ExitCode;
    }

    HashSet<string> ListDependencyAssemblies(string projectFolder, string framework, string coreclrFolder = null)
    {
        var tmpFile = Path.GetTempFileName();
        var argument = string.Format("list {0} --framework {1} --assemblies", projectFolder, framework);

        if (coreclrFolder != null)
        {
            argument += (" --runtime " + coreclrFolder);
        }

        int result;
        if (!IsMono)
        {
            result = ExecuteAndRedirectOutput("cmd", string.Format("/C dnu {0}", argument), tmpFile);
        }
        else 
        {
            result = ExecuteAndRedirectOutput("dnu", argument, tmpFile);
        }

        if (result != 0)
        {
            throw new InvalidOperationException(string.Format("Return value for the command listing assemblies for project under {0} is not zero ({1}).", projectFolder, result));
        }

        try
        {
            return new HashSet<string>(File.ReadAllLines(tmpFile).Where(l => File.Exists(l)));
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException(string.Format("Unexpected exception thrown while parsing assemblies list for project under {0}. ({1})", projectFolder, ex.Message));
        }
    }

    string FindPackageDirectory(string name)
    {
        var packagesDir = Environment.GetEnvironmentVariable("DNX_PACKAGES");

        if (string.IsNullOrEmpty(packagesDir))
        {
            var profileDirectory = Environment.GetEnvironmentVariable("USERPROFILE");

            if (string.IsNullOrEmpty(profileDirectory))
            {
                profileDirectory = Environment.GetEnvironmentVariable("HOME");
            }

            packagesDir = Path.Combine(profileDirectory, _defaultLocalRuntimeHomeDir, _packagesSubDir);
        }
        
        var packageMetadataDir = Path.Combine(packagesDir, name);
        
        if (!Directory.Exists(packageMetadataDir))
        {
            return null;
        }
        
        return Directory.GetDirectories(packageMetadataDir)
                        .OrderByDescending(d => d)
                        .FirstOrDefault();
    }
    
    bool IsMsbuildInstalled(string msBuildPath)
    {
        if (!File.Exists(msBuildPath))
        {
            Log.Warn("msbuild version 12 not found. Please ensure you have the VS 2013 C++ SDK installed.");
            return false;
        }
    
        return true;
    }

    string[] FindAllProjects(params string[] folders)
    {
      return FindAllFiles("project.json", folders);
    }

    string[] FindAllFiles(string fileName, params string[] folders)
    {
      return folders.Select(folder => Path.Combine("src", folder)) 
                    .Where(folder => Directory.Exists(folder)) 
                    .SelectMany(folder => Directory.GetFiles(folder, fileName, SearchOption.AllDirectories)) 
                    .ToArray();
    }

    void UpdateAllNuspecs(string sourcePath, string outputPath)
    {
        var sourceFiles = Directory.GetFiles(sourcePath, "*.nuspec");
        foreach (var nuspecFile in sourceFiles)
        {
            XDocument xdoc;
            using (var fs = File.OpenRead(nuspecFile))
            {
                xdoc = XDocument.Load(fs);
            }

            var filesNode = xdoc.Descendants("files").SingleOrDefault();

            foreach (var fileNode in filesNode.Elements("file"))
            {
                var srcAttr = fileNode.Attribute("src");
                if (srcAttr != null)
                {
                    srcAttr.Value = srcAttr.Value.Replace("\\", Path.DirectorySeparatorChar.ToString());
                }

                var excludeAttr = fileNode.Attribute("exclude");
                if (excludeAttr != null)
                {
                    excludeAttr.Value = excludeAttr.Value.Replace("\\", Path.DirectorySeparatorChar.ToString());
                }
            }

            var fileWriteTo = Path.Combine(outputPath, Path.GetFileName(nuspecFile));
            xdoc.Save(fileWriteTo);
        }
    }

    string FindRuntimeFolder()
    {
        var profileDirectory = Environment.GetEnvironmentVariable("USERPROFILE");

        if (string.IsNullOrEmpty(profileDirectory))
        {
            profileDirectory = Environment.GetEnvironmentVariable("HOME");
        }

        return Path.Combine(profileDirectory, _defaultLocalRuntimeHomeDir);
    }

    string FindRuntimePackagesFolder() 
    {
        return Path.Combine(FindRuntimeFolder(), _runtimesSubDir);
    }

    void InstallDevRuntime(string binPath)
    {
        var sourceDir = Path.GetDirectoryName(binPath);
        var sourceRuntime= Path.GetFileName(sourceDir);
        var destinationRuntime= sourceRuntime+ ".1.0.0-dev";
        var destinationDir = Path.Combine(FindRuntimePackagesFolder(), destinationRuntime);
    
        if (Directory.Exists(destinationDir)) 
        {
            // Nothing to do, just return
            return;
        }
    
        // Trim runtime name prefix part from alias to keep it short
        var alias = sourceRuntime.Substring(sourceRuntime.IndexOf('-') + 1) + "-dev";
    
        var symlinkProgram = "cmd";
        var symlinkProgramArgs = "/C mklink /J {0} {1}";
            
        var versionManagerProgram = "cmd";
        var versionManagerProgramArgs = "/C dnvm alias {0} {1}";
    
        if (IsMono)
        {
            symlinkProgram = "ln";
            symlinkProgramArgs = "-s {1} {0}";
            
            versionManagerProgram = "bash";
            versionManagerProgramArgs =
                "-c 'source " + 
                Path.Combine(FindRuntimeFolder(), "dnvm", "dnvm.sh") +
                " && dnvm alias {0} {1}'";
        }
    
        symlinkProgramArgs = String.Format(symlinkProgramArgs,
            destinationDir,
            sourceDir);
            
        versionManagerProgramArgs = String.Format(versionManagerProgramArgs,
            alias,
            destinationRuntime);
    
        Exec(symlinkProgram, symlinkProgramArgs);
        Exec(versionManagerProgram, versionManagerProgramArgs);
    }

    void UpdateTpa(string input, string[] assemblies, string output)
    {
        var tpa = File.ReadAllLines(input)
                      .Where(l => File.Exists(l))
                      .Select(l => Path.GetFileNameWithoutExtension(l))
                      .Concat(assemblies)
                      .OrderBy(s => s)
                      .ToArray();

        var content = new List<string>();

        content.Add(@"// This file will be dynamically updated during build to generate a ");
        content.Add(@"// minimal trusted platform assemblies list");
        content.Add(string.Empty);
        content.Add("#include \"stdafx.h\"");
        content.Add("#include \"tpa.h\"");
        content.Add(string.Empty);
        content.Add("BOOL CreateTpaBase(LPCTSTR** ppNames, size_t* pcNames, bool bNative)");
        content.Add("{");
        content.Add("    const size_t count = " + tpa.Length + ";");
        content.Add("    LPCTSTR* pArray = new LPCTSTR[count];");
        content.Add(string.Empty);
        content.Add("    if (bNative)");
        content.Add("    {");

        for (int i = 0; i < tpa.Length; ++i)
        {
            content.Add(string.Format("        pArray[{0}] = _T(\"{1}{2}\");", i, tpa[i], ".ni.dll"));
        }

        content.Add("    }");
        content.Add("    else");
        content.Add("    {");

        for (int i = 0; i < tpa.Length; ++i)
        {
            content.Add(string.Format("        pArray[{0}] = _T(\"{1}{2}\");", i, tpa[i], ".dll"));
        }

        content.Add("    }");
        content.Add(string.Empty);
        content.Add("    *ppNames = pArray;");
        content.Add("    *pcNames = count;");
        content.Add(string.Empty);
        content.Add("    return true;");
        content.Add("}");
        content.Add(string.Empty);
        content.Add("BOOL FreeTpaBase(const LPCTSTR* values)");
        content.Add("{");
        content.Add("    delete[] values;");
        content.Add(string.Empty);
        content.Add("    return true;");
        content.Add("}");

        File.WriteAllLines(output, content);
    }
}