[NaCl Addin] Fix dependencies in visual studio

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

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Collections;
 using System.IO;
 using System.Reflection;
 using System.Resources;
@@ skipping 10 matching lines @@
     public abstract class NaClToolTask : ToolTask
     {
         protected NaClToolTask(ResourceManager taskResources) : base(taskResources) { }
         public bool BuildingInIDE { get; set; }
         protected ITaskItem[] excludedInputPaths;
         private ITaskItem[] tlogReadFiles;
         private ITaskItem tlogCommandFile;
         private ITaskItem[] tlogWriteFiles;
         private CanonicalTrackedInputFiles trackedInputFiles;
         private bool skippedExecution;
-        private bool minimalRebuildFromTracking;
         private bool trackFileAccess;
         protected ITaskItem[] compileSourceList;
         protected XamlParser xamlParser;
 
         [Required]
+        public string PropertiesFile { get; set; }
+
+        [Required]
         public string TrackerLogDirectory { get; set; }
 
         [Required]
         public virtual ITaskItem[] Sources { get; set; }
 
         [Required]
         public bool OutputCommandLine { get; set; }
 
         [Required]
+        public bool MinimalRebuildFromTracking { get; set; }
+
+        [Required]
         public string Platform { get; set; }
 
         public virtual string OutputFile { get; set; }
 
         // Override default StandardOutputLoggingImportance so that we see the stdout from the
         // toolchain from within visual studio.
         protected override MessageImportance StandardOutputLoggingImportance
         {
             get { return MessageImportance.Normal; }
         }
@@ skipping 35 matching lines @@
             return Path.GetFileNameWithoutExtension(ToolName);
         }
 
         protected bool IsPNaCl()
         {
             return Platform.Equals("pnacl", StringComparison.OrdinalIgnoreCase);
         }
 
         protected bool Setup()
         {
-            this.SkippedExecution = false;
-
+            SkippedExecution = false;
             if (!ValidateParameters())
             {
                 return false;
             }
 
             if (IsPNaCl())
             {
                 if (!SDKUtilities.FindPython())
                 {
                     Log.LogError("PNaCl linking requires python in your executable path.");
                     return false;
                 }
             }
 
-            if (this.TrackFileAccess || this.MinimalRebuildFromTracking)
+            if (TrackFileAccess || MinimalRebuildFromTracking)
             {
-                this.SetTrackerLogPaths();
+                SetTrackerLogPaths();
             }
 
-            if (this.ForcedRebuildRequired() || this.MinimalRebuildFromTracking == false)
-            {
-                if (this.Sources == null || this.Sources.Length == 0)
-                {
-                    this.SkippedExecution = true;
-                }
-            }
-
+            CalcSourcesToBuild();
             return true;
         }
 
         protected virtual CanonicalTrackedOutputFiles OutputWriteTLog(ITaskItem[] inputs)
         {
             string path = Path.Combine(TlogDirectory, WriteTLogFilename);
             TaskItem item = new TaskItem(path);
             CanonicalTrackedOutputFiles trackedFiles =
                 new CanonicalTrackedOutputFiles(new TaskItem[] { item });
 
@@ skipping 30 matching lines @@
 
                 writer.WriteLine("^" + sourcePath);
                 foreach (ITaskItem source in Sources)
                 {
                     writer.WriteLine(Path.GetFullPath(source.ItemSpec).ToUpperInvariant());
                 }
                 writer.WriteLine(Path.GetFullPath(OutputFile).ToUpperInvariant());
             }
         }
 
+        protected virtual string TLogCommandForSource(ITaskItem source)
+        {
+            return GenerateResponseFileCommands();
+        }
+
         protected virtual void OutputCommandTLog(ITaskItem[] compiledSources)
         {
             string fullpath = TLogCommandFile.GetMetadata("FullPath");
             using (var writer = new StreamWriter(fullpath, false, Encoding.Unicode))
             {
-                string cmds = GenerateResponseFileCommands();
+                string cmds = TLogCommandForSource(Sources[0]);
                 string sourcePath = "";
                 foreach (ITaskItem source in Sources)
                 {
                     if (sourcePath != "")
                         sourcePath += "|";
                     sourcePath += Path.GetFullPath(source.ItemSpec).ToUpperInvariant();
                 }
 
                 writer.WriteLine("^" + sourcePath);
                 writer.WriteLine(cmds);
             }
         }
 
         public override bool Execute()
         {
-            bool  returnResult = base.Execute();
+            xamlParser = new XamlParser(PropertiesFile);
+            if (!Setup())
+                return false;
 
-            // Update tracker log files if execution occurred
-            //if (this.skippedExecution == false)
+            if (SkippedExecution)
+                return true;
+
+            bool res = base.Execute();
+            // Update tracker log files if execution was successful
+            if (res)
             {
                 CanonicalTrackedOutputFiles outputs = OutputWriteTLog(compileSourceList);
                 OutputReadTLog(compileSourceList, outputs);
                 OutputCommandTLog(compileSourceList);
             }
 
-            return returnResult;
+            return res;
         }
 
         protected override Encoding ResponseFileEncoding
         {
             get
             {
                 return Encoding.ASCII;
             }
         }
 
         protected virtual void SetTrackerLogPaths()
         {
-            if (this.TLogCommandFile == null)
+            if (TLogCommandFile == null)
             {
-                string commandFile = Path.Combine(this.TlogDirectory, this.CommandTLogFilename);
-                this.TLogCommandFile = new TaskItem(commandFile);
+                string commandFile = Path.Combine(TlogDirectory, CommandTLogFilename);
+                TLogCommandFile = new TaskItem(commandFile);
             }
 
-            if (this.TLogReadFiles == null)
+            if (TLogReadFiles == null)
             {
-                this.TLogReadFiles = new ITaskItem[this.ReadTLogFilenames.Length];
-                for (int n = 0; n < this.ReadTLogFilenames.Length; n++)
+                TLogReadFiles = new ITaskItem[ReadTLogFilenames.Length];
+                for (int n = 0; n < ReadTLogFilenames.Length; n++)
                 {
-                    string readFile = Path.Combine(this.TlogDirectory, this.ReadTLogFilenames[n]);
-                    this.TLogReadFiles[n] = new TaskItem(readFile);
+                    string readFile = Path.Combine(TlogDirectory, ReadTLogFilenames[n]);
+                    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);
+                TLogWriteFiles = new ITaskItem[1];
+                string writeFile = Path.Combine(TlogDirectory, WriteTLogFilename);
+                TLogWriteFiles[0] = new TaskItem(writeFile);
             }
         }
 
+        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 IDictionary<string, string> GenerateCommandLinesFromTlog()
+        {
+            IDictionary<string, string> cmdLineDictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            string tlogFilename = this.TLogCommandFile.GetMetadata("FullPath");
+            if (!File.Exists(tlogFilename))
+                return cmdLineDictionary;
+
+            using (StreamReader reader = File.OpenText(tlogFilename))
+            {
+                string[] filenames = null;
+                for (string lineStr = reader.ReadLine(); lineStr != null; lineStr = reader.ReadLine())
+                {
+                    if (lineStr.Length == 0 || (lineStr[0] == '^' && lineStr.Length == 1))
+                    {
+                        Log.LogError("Invalid line in command tlog");
+                        break;
+                    }
+                    else if (lineStr[0] == '^')
+                    {
+                        filenames = lineStr.Substring(1).Split('|');
+                    }
+                    else
+                    {
+                        foreach (string filename in filenames)
+                        {
+                            cmdLineDictionary[filename] = lineStr;
+                        }
+                    }
+                }
+            }
+            return cmdLineDictionary;
+        }
+
+        protected List<ITaskItem> GetOutOfDateSourcesFromCmdLineChanges()
+        {
+            //get dictionary of source + command lines
+            IDictionary<string, string> dictionary = 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;
+                currentCommandLine.Append(TLogCommandForSource(sourceItem));
+
+                string tlogCommandLine = null;
+                if (dictionary.TryGetValue(FileTracker.FormatRootingMarker(sourceItem), out tlogCommandLine))
+                {
+                    if (tlogCommandLine == null || !currentCommandLine.ToString().Equals(tlogCommandLine, StringComparison.Ordinal))
+                    {
+                        outOfDateSources.Add(sourceItem);
+                    }
+                }
+                else
+                {
+                    outOfDateSources.Add(sourceItem);
+                }
+            }
+            return outOfDateSources;
+        }
+
+        protected void CalcSourcesToBuild()
+        {
+            //check if full recompile is required otherwise perform incremental
+            if (ForcedRebuildRequired() || MinimalRebuildFromTracking == false)
+            {
+                CompileSourceList = Sources;
+                return;
+            }
+
+            //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 outputs = new CanonicalTrackedOutputFiles(this, TLogWriteFiles);
+            TrackedInputFiles = new CanonicalTrackedInputFiles(this,
+                                                               TLogReadFiles,
+                                                               Sources,
+                                                               ExcludedInputPaths,
+                                                               outputs,
+                                                               true,
+                                                               false);
+            ITaskItem[] outOfDateSourcesFromTracking = TrackedInputFiles.ComputeSourcesNeedingCompilation();
+
+            //merge out of date lists
+            CompileSourceList = MergeOutOfDateSources(outOfDateSourcesFromTracking, outOfDateSourcesFromCommandLine);
+            if (CompileSourceList.Length == 0)
+            {
+                SkippedExecution = true;
+                return;
+            }
+
+            //remove sources to compile from tracked file list
+            TrackedInputFiles.RemoveEntriesForSource(CompileSourceList);
+            outputs.RemoveEntriesForSource(CompileSourceList);
+            TrackedInputFiles.SaveTlog();
+            outputs.SaveTlog();
+        }
+
         [Output]
         public bool SkippedExecution
         {
             get
             {
                 return this.skippedExecution;
             }
             set
             {
                 this.skippedExecution = value;
             }
         }
 
+        [Output]
+        public ITaskItem[] CompileSourceList
+        {
+            get
+            {
+                return this.compileSourceList;
+            }
+            set
+            {
+                this.compileSourceList = 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;
             }
@@ skipping 40 matching lines @@
             get
             {
                 return this.excludedInputPaths;
             }
             set
             {
                 this.excludedInputPaths = value;
             }
         }
 
-        protected virtual string CommandTLogFilename
-        {
-            get
-            {
-                return BaseTool() + ".compile.command.1.tlog";
-            }
-        }
+        protected abstract string CommandTLogFilename { get; }
 
-        protected virtual string[] ReadTLogFilenames
-        {
-            get
-            {
-                return new string[] { BaseTool() + ".compile.read.1.tlog" };
-            }
-        }
+        protected abstract string WriteTLogFilename { get; }
 
-        protected virtual string WriteTLogFilename
-        {
-            get
-            {
-                return BaseTool() + ".compile.write.1.tlog";
-            }
-        }
+        protected abstract string[] ReadTLogFilenames { get; }
 
         public virtual string PlatformToolset
         {
             get
             {
                 return "GCC";
             }
         }
 
         protected override string GenerateFullPathToTool()
         {
             return this.ToolName;
         }
     }
 }