Cosmos/source2/Build/Cosmos.Build.MSBuild/BuildImage.cs

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
using Cosmos.Build.Common;
using Cosmos.Compiler.Builder;
using Cosmos.IL2CPU;
using System.IO;

namespace Cosmos.Build.MSBuild {

    public class BuildImage : AppDomainIsolatedTask
    {

		private Boolean buildFailed;

		public override bool Execute()
		{
            buildFailed = false;

			Log.LogMessage(MessageImportance.High, "Building Cosmos System Image");

			String buildOutputPath;
			String buildKernelAssemblyPath;
			Boolean buildUseInternalAssembler;
			TargetHost buildTarget;
			Framework buildFramework;

			if (System.IO.Path.IsPathRooted(this.OutputPath) == false)
			{ buildOutputPath = (new System.IO.DirectoryInfo(this.OutputPath)).FullName; }
			else
			{ buildOutputPath = this.OutputPath; }

			buildKernelAssemblyPath = System.IO.Path.Combine(buildOutputPath, this.KernelAssembly);
			buildUseInternalAssembler = this.UseInternalAssembler;
			buildFramework = EnumValue.Parse(this.Framework, Cosmos.Build.Common.Framework.MicrosoftNET);
			buildTarget = EnumValue.Parse(this.BuildTarget, TargetHost.QEMU);

			Log.LogMessage(MessageImportance.High, "Output Path: {0}", buildOutputPath);
			Log.LogMessage(MessageImportance.High, "Kernal Assembly: {0}", buildKernelAssemblyPath);
			Log.LogMessage(MessageImportance.High, "Use Internal Assembler: {0}", buildUseInternalAssembler);
			Log.LogMessage(MessageImportance.High, "Framework: {0}", buildFramework);
			Log.LogMessage(MessageImportance.High, "Target: {0}", buildTarget);

			System.Reflection.Assembly kernelAssembly;

			var builtEvent = new System.Threading.AutoResetEvent(false);
			var builder = new Builder();
            var xOptions = BuildOptions.Load();
            xOptions.Target = "ISO";            
            

			//builder.UseInternalAssembler = this.UseInternalAssembler;

			builder.CompileCompleted += delegate { builtEvent.Set(); };
            builder.LogMessage += delegate(LogSeverityEnum aSeverity, string aMessage)
                      {
                          switch (aSeverity)
                          {
                              case LogSeverityEnum.Informational:
                                  Log.LogMessage(aMessage);
                                  break;
                              case LogSeverityEnum.Warning:
                                  Log.LogWarning(aMessage);
                                  break;
                              case LogSeverityEnum.Error:
                                  Log.LogError(aMessage);
                                  this.buildFailed = true;
                                  break;
                          }

                      };

            kernelAssembly = System.Reflection.Assembly.LoadFile(Path.Combine(buildOutputPath, this.KernelAssembly));
			builder.TargetAssembly = kernelAssembly;

			builder.BeginCompile(xOptions);
			builtEvent.WaitOne();
            return (this.buildFailed == false) && !builder.HasErrors;
		}

		[Required]
		public string KernelAssembly
		{ get; set; }

		[Required]
		public string OutputPath
		{ get; set; }

		public Boolean UseInternalAssembler
		{ get; set; }

		public string BuildTarget
		{ get; set; }

		public string Framework
		{ get; set; }

	}
		
}