Make.cs

// Copyright (c) 2015 SIL International
// This software is licensed under the LGPL, version 2.1 or later
// (http://www.gnu.org/licenses/lgpl-2.1.html)

using System;
using System.IO;
using System.Text;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;

namespace FwBuildTasks
{
	public class Make : ToolTask
	{
		public Make() { }

		/// <summary>
		/// Gets or sets the path to the makefile.
		/// </summary>
		[Required]
		public string Makefile { get; set; }

		/// <summary>
		/// Gets or sets the build configuration (Debug, Release, Profile, Bounds).
		/// </summary>
		[Required]
		public string Configuration { get; set; }

		/// <summary>
		/// Gets or sets the root directory of the build (repository) tree.
		/// </summary>
		[Required]
		public string BuildRoot { get; set; }

		/// <summary>
		/// Optional override for build output root (BUILD_OUTPUT in makefiles).
		/// </summary>
		public string BuildOutput { get; set; }

		/// <summary>
		/// Optional override for final output directory (OUT_DIR in makefiles).
		/// When provided, this takes precedence over the makefile's default OUT_DIR.
		/// </summary>
		public string OutDir { get; set; }

		/// <summary>
		/// The build architecture (x86 or x64)
		/// </summary>
		public string BuildArch { get; set; }

		/// <summary>
		/// Gets or sets the intermediate output directory.
		/// When specified, this overrides the makefile's default INT_DIR.
		/// </summary>
		public string IntDir { get; set; }

		/// <summary>
		/// Gets or sets the object output directory.
		/// When specified, this overrides the makefile's default OBJ_DIR.
		/// Takes precedence over IntDir since OBJ_DIR is the parent of INT_DIR.
		/// </summary>
		public string ObjDir { get; set; }

		/// <summary>
		/// Gets or sets the target inside the Makefile.
		/// </summary>
		public string Target { get; set; }

		/// <summary>
		/// Gets the build "type" (d, r, p, b).
		/// This can be derived from the build configuration.
		/// </summary>
		private string BuildType
		{
			get
			{
				switch (Configuration)
				{
					case "Debug":
						return "d";
					case "Release":
						return "r";
					case "Profile":
						return "p";
					case "Bounds":
						return "b";
					default:
						return "d";
				}
			}
		}

		/// <summary>
		/// Gets or sets the working directory.
		/// </summary>
		/// <value>The working directory.</value>
		/// <returns>
		/// The directory in which to run the executable file, or a null reference (Nothing in Visual Basic) if the executable file should be run in the current directory.
		/// </returns>
		public string WorkingDirectory { get; set; }

		#region Task Overrides
		protected override string ToolName
		{
			get
			{
				if (Environment.OSVersion.Platform == PlatformID.Unix)
					return "make";
				else
					return "nmake.exe";
			}
		}

		private static string FindVisualStudioToolPath(string vcInstallDir, string toolName)
		{
			if (String.IsNullOrEmpty(vcInstallDir) || !Directory.Exists(vcInstallDir))
				return null;

			string toolsRoot = Path.Combine(vcInstallDir, "Tools", "MSVC");
			if (!Directory.Exists(toolsRoot))
				return null;

			string[] versionDirs = Directory.GetDirectories(toolsRoot);
			Array.Sort(versionDirs, CompareVersionDirectories);

			foreach (string versionDir in versionDirs)
			{
				string[] candidateDirs =
				{
					Path.Combine(versionDir, "bin", "Hostx64", "x64"),
					Path.Combine(versionDir, "bin", "Hostx64", "x86"),
					Path.Combine(versionDir, "bin", "Hostx86", "x86"),
					Path.Combine(versionDir, "bin", "Hostx86", "x64")
				};

				foreach (string candidateDir in candidateDirs)
				{
					if (File.Exists(Path.Combine(candidateDir, toolName)))
						return candidateDir;
				}
			}

			return null;
		}

		private static int CompareVersionDirectories(string left, string right)
		{
			string leftName = Path.GetFileName(left);
			string rightName = Path.GetFileName(right);

			Version leftVersion;
			Version rightVersion;
			bool leftIsVersion = Version.TryParse(leftName, out leftVersion);
			bool rightIsVersion = Version.TryParse(rightName, out rightVersion);

			if (leftIsVersion && rightIsVersion)
			{
				int versionComparison = rightVersion.CompareTo(leftVersion);
				if (versionComparison != 0)
					return versionComparison;
			}
			else if (leftIsVersion != rightIsVersion)
			{
				return rightIsVersion.CompareTo(leftIsVersion);
			}

			return StringComparer.OrdinalIgnoreCase.Compare(rightName, leftName);
		}

		private void CheckToolPath()
		{
			string path = Environment.GetEnvironmentVariable("PATH");
			string vcInstallDir = Environment.GetEnvironmentVariable("VCINSTALLDIR");
			//Console.WriteLine("DEBUG Make Task: PATH='{0}'", path);
			string makePath = ToolPath == null ? String.Empty : ToolPath.Trim();
			if (!String.IsNullOrEmpty(makePath) && File.Exists(Path.Combine(makePath, ToolName)))
			{
				ToolPath = makePath;
				return;
			}
			if (Environment.OSVersion.Platform == PlatformID.Unix)
			{
				ToolPath = "/usr/bin";
				if (File.Exists(Path.Combine(ToolPath, ToolName)))
					return;
			}
			string[] splitPath = path.Split(new char[] { Path.PathSeparator });
			foreach (var dir in splitPath)
			{
				if (File.Exists(Path.Combine(dir, ToolName)))
				{
					ToolPath = dir;
					return;
				}
			}
			// Fall Back to the install directory (if VCINSTALLDIR is set)
			if (!String.IsNullOrEmpty(vcInstallDir))
			{
				string visualStudioToolPath = FindVisualStudioToolPath(vcInstallDir, ToolName);
				if (!String.IsNullOrEmpty(visualStudioToolPath))
				{
					ToolPath = visualStudioToolPath;
					return;
				}

				string legacyToolPath = Path.Combine(vcInstallDir, "bin");
				if (File.Exists(Path.Combine(legacyToolPath, ToolName)))
				{
					ToolPath = legacyToolPath;
					return;
				}

				ToolPath = String.Empty;
			}
			else
			{
				// VCINSTALLDIR not set - likely not in a VS Developer environment
				// Let MSBuild try to find the tool in PATH
				ToolPath = String.Empty;
			}
		}

		protected override string GenerateFullPathToTool()
		{
			CheckToolPath();
			return Path.Combine(ToolPath, ToolName);
		}

		protected override string GenerateCommandLineCommands()
		{
			var bldr = new CommandLineBuilder();
			if (Environment.OSVersion.Platform == PlatformID.Unix)
			{
				bldr.AppendSwitchIfNotNull("BUILD_CONFIG=", Configuration);
				bldr.AppendSwitchIfNotNull("BUILD_TYPE=", BuildType);
				bldr.AppendSwitchIfNotNull("BUILD_ROOT=", BuildRoot);
				bldr.AppendSwitchIfNotNull("BUILD_ARCH=", BuildArch);
				bldr.AppendSwitchIfNotNull("BUILD_OUTPUT=", BuildOutput);
				bldr.AppendSwitchIfNotNull("OUT_DIR=", OutDir);
				bldr.AppendSwitchIfNotNull("OBJ_DIR=", ObjDir);
				bldr.AppendSwitchIfNotNull("INT_DIR=", IntDir);
				bldr.AppendSwitchIfNotNull("-C", Path.GetDirectoryName(Makefile));
				if (String.IsNullOrEmpty(Target))
					bldr.AppendSwitch("all");
				else
					bldr.AppendSwitch(Target);
			}
			else
			{
				bldr.AppendSwitch("/nologo");
				bldr.AppendSwitchIfNotNull("BUILD_CONFIG=", Configuration);
				bldr.AppendSwitchIfNotNull("BUILD_TYPE=", BuildType);
				bldr.AppendSwitchIfNotNull("BUILD_ROOT=", BuildRoot);
				bldr.AppendSwitchIfNotNull("BUILD_ARCH=", BuildArch);
				bldr.AppendSwitchIfNotNull("BUILD_OUTPUT=", BuildOutput);
				bldr.AppendSwitchIfNotNull("OUT_DIR=", OutDir);
				bldr.AppendSwitchIfNotNull("OBJ_DIR=", ObjDir);
				bldr.AppendSwitchIfNotNull("INT_DIR=", IntDir);
				bldr.AppendSwitchIfNotNull("/f ", Makefile);
				if (!String.IsNullOrEmpty(Target))
					bldr.AppendSwitch(Target);
			}
			return bldr.ToString();
		}

		/// <summary>
		/// Returns the directory in which to run the executable file, or a null reference if the executable file should be run in the current directory.
		/// </summary>
		protected override string GetWorkingDirectory()
		{
			return String.IsNullOrEmpty(WorkingDirectory)
				? base.GetWorkingDirectory()
				: WorkingDirectory;
		}
		#endregion
	}
}