Add PNaCl support for VS addin.

visual_studio/NativeClientVSAddIn/NaCl.Build.CPPTasks/NaClCompile.cs

 
 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Collections;
 using System.IO;
 using System.Reflection;
 using System.Resources;
 using System.Windows.Forms;
 using Microsoft.Build.Framework;
 using Microsoft.Win32;
 using Microsoft.Build.Utilities;
 using System.Collections.Specialized;
 
 using System.Diagnostics;
 
 namespace NaCl.Build.CPPTasks
 {
-    public class NaClCompile : ToolTask
+    public class NaClCompile : NaClToolTask
     {
-        private XamlParser m_XamlParser;
-        private ITaskItem[] excludedInputPaths;
-        private ITaskItem[] tlogReadFiles;
-        private ITaskItem tlogCommandFile;
-        private ITaskItem[] tlogWriteFiles;
-        private CanonicalTrackedInputFiles trackedInputFiles;
-        private bool skippedExecution;
-        private ITaskItem[] compileSourceList;
         public bool BuildingInIDE { get; set; }
-        private string m_toolname;
-        private bool trackFileAccess;
-        private bool minimalRebuildFromTracking;
-        private string pathToLog;
 
         [Required]
         public string PropertiesFile { get; set; }
 
         [Required]
-        public ITaskItem[] Sources { get; set; }
-
-        [Required]
         public string NaCLCompilerPath { get; set; }
 
         [Required]
         public bool OutputCommandLine { get; set; }
 
+        [Required]
+        public string Platform { get; set; }
+
         public int ProcessorNumber { get; set; }
 
         public bool MultiProcessorCompilation { get; set; }
 
-        [Required]
-        public string TrackerLogDirectory { get; set; }
-
+        [Obsolete]
         protected override StringDictionary EnvironmentOverride
         {
             get {
                 string show = OutputCommandLine ? "1" : "0";
                 string cores = Convert.ToString(ProcessorNumber);
                 return new StringDictionary() {
                       {"NACL_GCC_CORES", cores},
                       {"NACL_GCC_SHOW_COMMANDS", show }
                 };
             }
         }
 
-        protected override string GenerateFullPathToTool() { return ToolName; }
+        protected override string GenerateFullPathToTool()
+        {
+            return ToolName;
+        }
 
         public NaClCompile()
             : base(new ResourceManager("NaCl.Build.CPPTasks.Properties.Resources", Assembly.GetExecutingAssembly()))
         {
-            this.pathToLog = string.Empty;
             this.EnvironmentVariables = new string[] { "CYGWIN=nodosfilewarning", "LC_CTYPE=C" };
         }
 
         protected IDictionary<string, string> GenerateCommandLinesFromTlog()
         {
             IDictionary<string, string> cmdLineDictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
             string tlogFilename = this.TLogCommandFile.GetMetadata("FullPath");
             if (File.Exists(tlogFilename))
             {
                 using (StreamReader reader = File.OpenText(tlogFilename))
@@ skipping 33 matching lines @@
             // the objectfile is created as <ObjectFileName>/<basename>.obj.  Here
             // we mimic this behaviour.
             if ((File.GetAttributes(objectFilePath) & FileAttributes.Directory) != 0)
             {
                 objectFilePath = Path.Combine(objectFilePath, Path.GetFileName(source.ItemSpec));
                 objectFilePath = Path.ChangeExtension(objectFilePath, ".obj");
             }
             return objectFilePath;
         }
 
-        private void ConstructReadTLog(ITaskItem[] compiledSources, CanonicalTrackedOutputFiles outputs)
+        protected override void OutputReadTLog(ITaskItem[] compiledSources, CanonicalTrackedOutputFiles outputs)
         {
             string trackerPath = Path.GetFullPath(TlogDirectory + ReadTLogFilenames[0]);
 
             //save tlog for sources not compiled during this execution
             TaskItem readTrackerItem = new TaskItem(trackerPath);
             CanonicalTrackedInputFiles files = new CanonicalTrackedInputFiles(new TaskItem[] { readTrackerItem }, Sources, outputs, false, false);
             files.RemoveEntriesForSource(compiledSources);
             files.SaveTlog();
 
             //add tlog information for compiled sources
@@ skipping 43 matching lines @@
 
                     }
                     catch (Exception)
                     {
                         Log.LogError("Failed to update " + readTrackerItem + " for " + sourcePath);
                     }
                 }
             }
         }
 
-        private CanonicalTrackedOutputFiles OutputWriteTrackerLog(ITaskItem[] compiledSources)
+        protected override CanonicalTrackedOutputFiles OutputWriteTLog(ITaskItem[] compiledSources)
         {
             string path = Path.Combine(TlogDirectory, WriteTLogFilename);
             TaskItem item = new TaskItem(path);
             CanonicalTrackedOutputFiles trackedFiles = new CanonicalTrackedOutputFiles(new TaskItem[] { item });
 
             foreach (ITaskItem sourceItem in compiledSources)
             {
                 //remove this entry associated with compiled source which is about to be recomputed
                 trackedFiles.RemoveEntriesForSource(sourceItem);
 
                 //add entry with updated information
                 trackedFiles.AddComputedOutputForSourceRoot(Path.GetFullPath(sourceItem.ItemSpec).ToUpperInvariant(),
                                                             Path.GetFullPath(GetObjectFile(sourceItem)).ToUpperInvariant());
             }
 
             //output tlog
             trackedFiles.SaveTlog();
 
             return trackedFiles;
         }
 
-        private void OutputCommandTrackerLog(ITaskItem[] compiledSources)
+        protected override void OutputCommandTLog(ITaskItem[] compiledSources)
         {
             IDictionary<string, string> commandLines = GenerateCommandLinesFromTlog();
 
             //
             if (compiledSources != null)
             {
                 foreach (ITaskItem source in compiledSources)
                 {
                     string rmSource = FileTracker.FormatRootingMarker(source);
                     commandLines[rmSource] = GenerateCommandLineFromProps(source) + " " + source.GetMetadata("FullPath").ToUpperInvariant();
@@ skipping 19 matching lines @@
             if (sourceFile != null)
             {
                 // Remove rtti items as they are not relevant in C compilation and will produce warnings
                 if (SourceIsC(sourceFile.ToString()))
                 {
                     commandLine.Replace("-fno-rtti", "");
                     commandLine.Replace("-frtti", "");
                 }
 
                 //build command line from components and add required switches
-                string props = m_XamlParser.Parse(sourceFile, fullOutputName);
+                string props = xamlParser.Parse(sourceFile, fullOutputName);
                 commandLine.Append(props);
-                commandLine.Append(" -MD -c ");
+                commandLine.Append(" -c ");
             }
 
             return commandLine.ToString();
         }
 
         protected ITaskItem[] MergeOutOfDateSources(ITaskItem[] outOfDateSourcesFromTracking, List<ITaskItem> outOfDateSourcesFromCommandLineChanges)
         {
             List<ITaskItem> mergedSources = new List<ITaskItem>(outOfDateSourcesFromTracking);
 
             foreach (ITaskItem item in outOfDateSourcesFromCommandLineChanges)
             {
                 if (!mergedSources.Contains(item))
                 {
                     mergedSources.Add(item);
                 }
             }
 
             return mergedSources.ToArray();
         }
 
-        protected bool ForcedRebuildRequired()
-        {
-            string tlogCommandPath = null;
-
-            try
-            {
-                tlogCommandPath = this.TLogCommandFile.GetMetadata("FullPath");
-            }
-            catch (Exception exception)
-            {
-                if (exception is InvalidOperationException || exception is NullReferenceException)
-                    return true;
-                else
-                    throw;
-            }
-
-            //if command tlog file does not exist then force rebuild is required
-            if (File.Exists(tlogCommandPath) == false)
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-
         private int Compile(string pathToTool)
         {
+            if (Platform.Equals("pnacl", StringComparison.OrdinalIgnoreCase))
+            {
+                if (!GCCUtilities.FindPython())
+                {
+                    Log.LogError("PNaCl compilation requires python in your executable path.");
+                    return -1;
+                }
+            }
+
             // If multiprocess complication is enabled (not the VS default)
             // and the number of processors to use is not 1, then use the
             // compiler_wrapper python script to run multiple instances of
             // gcc
             if (MultiProcessorCompilation && ProcessorNumber != 1)
             {
-
-                string envvar = (string)Registry.GetValue("HKEY_CURRENT_USER\\Environment", "PATH", "");
-                List<string> pathList = new List<string>(envvar.Split(';'));
-                envvar = (string)Registry.GetValue("HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\Control\\Session Manager\\Environment", "PATH", "");
-                pathList.AddRange(new List<string>(envvar.Split(';')));
-                string pythonExe = null;
-                foreach (string path in pathList)
+                if (!GCCUtilities.FindPython())
                 {
-                    string testPath = Path.Combine(path, "python.bat");
-                    if (File.Exists(testPath))
-                    {
-                        pythonExe = testPath;
-                        break;
-                    }
-                    testPath = Path.Combine(path, "python.exe");
-                    if (File.Exists(testPath))
-                    {
-                        pythonExe = testPath;
-                        break;
-                    }
-                }
-
-                if (pythonExe == null)
-                {
-                    MessageBox.Show("Multi-processor Compilation with NaCl requires that python available in the PATH.\n" +
-                                    "Please disable Multi-processor Compilation in the project properties or add python " +
-                                    "to the your PATH\n" +
+                    MessageBox.Show("Multi-processor Compilation with NaCl requires that python " +
+                                    "be available in the visual studio executable path.\n" +
+                                    "Please disable Multi-processor Compilation in the project " +
+                                    "properties or add python to the your executable path.\n" +
                                     "Falling back to serial compilation.\n");
                 }
                 else
                 {
-                    return CompileParallel(pathToTool, pythonExe);
+                    return CompileParallel(pathToTool);
                 }
             }
             return CompileSerial(pathToTool);
         }
 
         private int CompileSerial(string pathToTool)
         {
             int returnCode = 0;
-
             foreach (ITaskItem sourceItem in CompileSourceList)
             {
                 try
                 {
                     string commandLine = GenerateCommandLineFromProps(sourceItem, true);
                     commandLine += "\"" + GCCUtilities.ConvertPathWindowsToPosix(sourceItem.ToString()) + "\"";
 
                     if (OutputCommandLine)
                     {
                         string logMessage = pathToTool + " " + commandLine;
                         Log.LogMessage(logMessage);
                     }
                     else
                     {
                         base.Log.LogMessage(Path.GetFileName(sourceItem.ToString()));
                     }
 
-
                     // compile
                     returnCode = base.ExecuteTool(pathToTool, commandLine, string.Empty);
                 }
                 catch (Exception)
                 {
                     returnCode = base.ExitCode;
                 }
 
                 //abort if an error was encountered
                 if (returnCode != 0)
                 {
                     return returnCode;
                 }
             }
             return returnCode;
         }
 
-        private int CompileParallel(string pathToTool, string pythonExe)
+        private int CompileParallel(string pathToTool)
         {
             int returnCode = 0;
 
             // Compute sources that can be compiled together.
             Dictionary<string, List<ITaskItem>> srcGroups =
                     new Dictionary<string, List<ITaskItem>>();
 
             foreach (ITaskItem sourceItem in CompileSourceList)
             {
                 string commandLine = GenerateCommandLineFromProps(sourceItem);
@@ skipping 18 matching lines @@
 
                 foreach (ITaskItem sourceItem in sources)
                 {
                     string src = GCCUtilities.ConvertPathWindowsToPosix(sourceItem.ToString());
                     cmd += " \"" + src + "\"";
                 }
 
                 try
                 {
                     // compile this group of sources
-                    returnCode = base.ExecuteTool(pythonExe, cmd, "\"" + pythonScript + "\"");
+                    returnCode = base.ExecuteTool("python", cmd, "\"" + pythonScript + "\"");
                 }
                 catch (Exception e)
                 {
                     Log.LogMessage("compiler exception: {0}", e);
                     returnCode = base.ExitCode;
                 }
 
                 //abort if an error was encountered
                 if (returnCode != 0)
                     break;
@@ skipping 17 matching lines @@
             {
                 returnCode = Compile(pathToTool);
             }
             finally
             {
 
             }
             return returnCode;
         }
 
-        protected override bool SkipTaskExecution()
-        {
-            return this.skippedExecution;
-        }
-
         protected void CalcSourcesToCompile()
         {
-            if (this.TrackFileAccess || this.MinimalRebuildFromTracking)
-            {
-                this.SetTrackerLogPaths();
-            }
-
             //check if full recompile is required otherwise perform incremental
             if (this.ForcedRebuildRequired() || this.MinimalRebuildFromTracking == false)
             {
                 this.CompileSourceList = this.Sources;
-                if (this.CompileSourceList == null || this.CompileSourceList.Length == 0)
-                {
-                    this.SkippedExecution = true;
-                }
+                return;
             }
-            else
+
+            //retrieve list of sources out of date due to command line changes
+            List<ITaskItem> outOfDateSourcesFromCommandLine = GetOutOfDateSourcesFromCmdLineChanges();
+
+            //retrieve sources out of date due to tracking
+            CanonicalTrackedOutputFiles trackedOutputFiles = new CanonicalTrackedOutputFiles(this, this.TLogWriteFiles);
+            this.TrackedInputFiles = new CanonicalTrackedInputFiles(this,
+                                                                    this.TLogReadFiles,
+                                                                    this.Sources,
+                                                                    this.ExcludedInputPaths,
+                                                                    trackedOutputFiles,
+                                                                    true,
+                                                                    false);
+            ITaskItem[] outOfDateSourcesFromTracking = this.TrackedInputFiles.ComputeSourcesNeedingCompilation();
+
+            //merge out of date lists
+            CompileSourceList = MergeOutOfDateSources(outOfDateSourcesFromTracking, outOfDateSourcesFromCommandLine);
+
+            if (this.CompileSourceList.Length == 0)
             {
-                //retrieve list of sources out of date due to command line changes
-                List<ITaskItem> outOfDateSourcesFromCommandLineChanges = this.GetOutOfDateSourcesFromCommandLineChanges();
+                this.SkippedExecution = true;
+                return;
+            }
 
-                //retrieve sources out of date due to tracking
-                CanonicalTrackedOutputFiles trackedOutputFiles = new CanonicalTrackedOutputFiles(this, this.TLogWriteFiles);
-                this.TrackedInputFiles = new CanonicalTrackedInputFiles(this, this.TLogReadFiles, this.Sources, this.ExcludedInputPaths, trackedOutputFiles, true, false);
-                ITaskItem[] outOfDateSourcesFromTracking = this.TrackedInputFiles.ComputeSourcesNeedingCompilation();
-
-                //merge out of date lists
-                this.CompileSourceList = this.MergeOutOfDateSources(outOfDateSourcesFromTracking, outOfDateSourcesFromCommandLineChanges);
-
-                if (this.CompileSourceList.Length == 0)
-                {
-                    this.SkippedExecution = true;
-                }
-                else
-                {
-                    //remove sources to compile from tracked file list
-                    this.TrackedInputFiles.RemoveEntriesForSource(this.CompileSourceList);
-                    trackedOutputFiles.RemoveEntriesForSource(this.CompileSourceList);
-                    this.TrackedInputFiles.SaveTlog();
-                    trackedOutputFiles.SaveTlog();
-
-                    this.SkippedExecution = false;
-                }
-            }
+            //remove sources to compile from tracked file list
+            this.TrackedInputFiles.RemoveEntriesForSource(this.CompileSourceList);
+            trackedOutputFiles.RemoveEntriesForSource(this.CompileSourceList);
+            this.TrackedInputFiles.SaveTlog();
+            trackedOutputFiles.SaveTlog();
         }
 
         protected bool SourceIsC(string sourceFilename)
         {
             string fileExt = Path.GetExtension(sourceFilename.ToString());
 
             if (fileExt == ".c")
                 return true;
             else
                 return false;
         }
 
         public override bool Execute()
         {
             bool returnResult = false;
 
             try
             {
-                m_XamlParser = new XamlParser(PropertiesFile);
-                m_toolname = Path.GetFileNameWithoutExtension(ToolName);
-                ValidateParameters();
+                xamlParser = new XamlParser(PropertiesFile);
+                if (!Setup())
+                    return false;
                 CalcSourcesToCompile();
-
                 returnResult = base.Execute();
-
-                // Update tracker log files if execution occurred
-                //if (this.skippedExecution == false)
-                {
-                    CanonicalTrackedOutputFiles outputs = OutputWriteTrackerLog(CompileSourceList);
-                    ConstructReadTLog(CompileSourceList, outputs);
-                    OutputCommandTrackerLog(CompileSourceList);
-                }
             }
             finally
             {
 
             }
 
             return returnResult;
         }
 
-        protected List<ITaskItem> GetOutOfDateSourcesFromCommandLineChanges()
+        protected List<ITaskItem> GetOutOfDateSourcesFromCmdLineChanges()
         {
             //get dictionary of source + command lines
             IDictionary<string, string> dictionary = this.GenerateCommandLinesFromTlog();
             List<ITaskItem> outOfDateSources = new List<ITaskItem>();
 
             //add sources to out of date list if the tlog dictionary string do not match the generated command line string
             StringBuilder currentCommandLine = new StringBuilder(GCCUtilities.s_CommandLineLength);
             foreach (ITaskItem sourceItem in Sources)
             {
                 currentCommandLine.Length = 0;
@@ skipping 11 matching lines @@
                     }
                 }
                 else
                 {
                     outOfDateSources.Add(sourceItem);
                 }
             }
             return outOfDateSources;
         }
 
-        protected virtual void SetTrackerLogPaths()
-        {
-            if (this.TLogCommandFile == null)
-            {
-                string commandFile = Path.Combine(this.TlogDirectory, this.CommandTLogFilename);
-                this.TLogCommandFile = new TaskItem(commandFile);
-            }
-
-            if (this.TLogReadFiles == null)
-            {
-                this.TLogReadFiles = new ITaskItem[this.ReadTLogFilenames.Length];
-                for (int n = 0; n < this.ReadTLogFilenames.Length; n++)
-                {
-                    string readFile = Path.Combine(this.TlogDirectory, this.ReadTLogFilenames[n]);
-                    this.TLogReadFiles[n] = new TaskItem(readFile);
-                }
-            }
-
-            if (this.TLogWriteFiles == null)
-            {
-                this.TLogWriteFiles = new ITaskItem[1];
-                string writeFile = Path.Combine(this.TlogDirectory, this.WriteTLogFilename);
-                this.TLogWriteFiles[0] = new TaskItem(writeFile);
-            }
-        }
-
-
-        //props
-        protected string CommandTLogFilename
-        {
-            get
-            {
-                return m_toolname + ".compile.command.1.tlog";
-            }
-        }
-
-        protected string[] ReadTLogFilenames
-        {
-            get
-            {
-                return new string[] { m_toolname + ".compile.read.1.tlog" };
-            }
-        }
-
-        [Output]
-        public bool SkippedExecution
-        {
-            get
-            {
-                return this.skippedExecution;
-            }
-            set
-            {
-                this.skippedExecution = value;
-            }
-        }
-
-        public ITaskItem TLogCommandFile
-        {
-            get
-            {
-                return this.tlogCommandFile;
-            }
-            set
-            {
-                this.tlogCommandFile = value;
-            }
-        }
-
-        protected string TlogDirectory
-        {
-            get
-            {
-                if (this.TrackerLogDirectory != null)
-                {
-                    return this.TrackerLogDirectory;
-                }
-                return string.Empty;
-            }
-        }
-
-        public bool MinimalRebuildFromTracking
-        {
-            get
-            {
-                return this.minimalRebuildFromTracking;
-            }
-            set
-            {
-                this.minimalRebuildFromTracking = value;
-            }
-        }
-
-
-        public ITaskItem[] TLogReadFiles
-        {
-            get
-            {
-                return this.tlogReadFiles;
-            }
-            set
-            {
-                this.tlogReadFiles = value;
-            }
-        }
-
-        public ITaskItem[] ExcludedInputPaths
-        {
-            get
-            {
-                return this.excludedInputPaths;
-            }
-            set
-            {
-                this.excludedInputPaths = value;
-            }
-        }
-
-
-        public ITaskItem[] TLogWriteFiles
-        {
-            get
-            {
-                return this.tlogWriteFiles;
-            }
-            set
-            {
-                this.tlogWriteFiles = value;
-            }
-        }
-
-        protected string WriteTLogFilename
-        {
-            get
-            {
-                return m_toolname + ".compile.write.1.tlog";
-            }
-        }
-
-        public bool TrackFileAccess
-        {
-            get
-            {
-                return this.trackFileAccess;
-            }
-            set
-            {
-                this.trackFileAccess = value;
-            }
-        }
-
-        protected CanonicalTrackedInputFiles TrackedInputFiles
-        {
-            get
-            {
-                return this.trackedInputFiles;
-            }
-            set
-            {
-                this.trackedInputFiles = value;
-            }
-        }
-
         [Output]
         public ITaskItem[] CompileSourceList
         {
             get
             {
                 return this.compileSourceList;
             }
             set
             {
                 this.compileSourceList = value;
             }
         }
 
         protected override string ToolName
         {
             get
             {
                 return NaCLCompilerPath;
             }
         }
 
-        protected override Encoding ResponseFileEncoding
-        {
-            get
-            {
-                return Encoding.ASCII;
-            }
-        }
     }
 }