[NaCl Addin] Fix dependencies in visual studio

visual_studio/NativeClientVSAddIn/NaCl.Build.CPPTasks/NaClCompile.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;
 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 : NaClToolTask
     {
         [Required]
-        public string PropertiesFile { get; set; }
-
-        [Required]
         public string NaCLCompilerPath { get; set; }
 
         public int ProcessorNumber { get; set; }
 
         public bool MultiProcessorCompilation { get; set; }
 
         [Required]
         public string ConfigurationType { 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 }
                 };
             }
         }
 
         public NaClCompile()
             : base(new ResourceManager("NaCl.Build.CPPTasks.Properties.Resources", Assembly.GetExecutingAssembly()))
         {
             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))
-                {
-                    string filename = string.Empty;
-                    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] == '^')
-                        {
-                            filename = lineStr.Substring(1);
-                        }
-                        else
-                        {
-                            cmdLineDictionary[filename] = lineStr;
-                        }
-                    }
-                }
-            }
-            return cmdLineDictionary;
-        }
-
         protected override void LogEventsFromTextOutput(string singleLine, MessageImportance messageImportance)
         {
             base.LogEventsFromTextOutput(GCCUtilities.ConvertGCCOutput(singleLine), messageImportance);
         }
 
         static string GetObjectFile(ITaskItem source)
         {
             string objectFilePath = Path.GetFullPath(source.GetMetadata("ObjectFileName"));
             // cl.exe will accept a folder name as the ObjectFileName in which case
             // the objectfile is created as <ObjectFileName>/<basename>.obj.  Here
@@ skipping 40 matching lines @@
                             {
                                 //source itself not required
                                 if (filename == sourcePath)
                                     continue;
 
                                 if (File.Exists(filename) == false)
                                 {
                                     Log.LogMessage(MessageImportance.High, "File " + sourcePath + " is missing dependency " + filename);
                                 }
 
-                                writer.WriteLine(filename);
+                                string fname = filename.ToUpperInvariant();
+                                fname = Path.GetFullPath(fname);
+                                writer.WriteLine(fname);
                             }
 
                             //remove d file
                             try
                             {
                                 File.Delete(depFilePath);
                             }
                             finally
                             {
 
@@ skipping 24 matching lines @@
                 trackedFiles.AddComputedOutputForSourceRoot(Path.GetFullPath(sourceItem.ItemSpec).ToUpperInvariant(),
                                                             Path.GetFullPath(GetObjectFile(sourceItem)).ToUpperInvariant());
             }
 
             //output tlog
             trackedFiles.SaveTlog();
 
             return trackedFiles;
         }
 
+        protected override string TLogCommandForSource(ITaskItem source)
+        {
+            return GenerateCommandLineForSource(source) + " " + source.GetMetadata("FullPath").ToUpperInvariant();
+        }
+
         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();
+                    commandLines[rmSource] = TLogCommandForSource(source);
                 }
             }
 
             //write tlog
             using (StreamWriter writer = new StreamWriter(this.TLogCommandFile.GetMetadata("FullPath"), false, Encoding.Unicode))
             {
                 foreach (KeyValuePair<string, string> p in commandLines)
                 {
                     string keyLine = "^" + p.Key;
                     writer.WriteLine(keyLine);
                     writer.WriteLine(p.Value);
                 }
             }
         }
 
-        protected string GenerateCommandLineFromProps(ITaskItem sourceFile,
+        protected string GenerateCommandLineForSource(ITaskItem sourceFile,
                                                       bool fullOutputName=false)
         {
             StringBuilder commandLine = new StringBuilder(GCCUtilities.s_CommandLineLength);
 
-            if (sourceFile != null)
+            //build command line from components and add required switches
+            string props = xamlParser.Parse(sourceFile, fullOutputName);
+            commandLine.Append(props);
+            commandLine.Append(" -c");
+
+            // Remove rtti items as they are not relevant in C compilation and will 
+            // produce warnings
+            if (SourceIsC(sourceFile.ToString()))
             {
-                //build command line from components and add required switches
-                string props = xamlParser.Parse(sourceFile, fullOutputName);
-                commandLine.Append(props);
-                commandLine.Append(" -c ");
+                commandLine.Replace("-fno-rtti", "");
+                commandLine.Replace("-frtti", "");
+            }
 
-                // 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", "");
-                }
-
-                if (ConfigurationType == "DynamicLibrary")
-                {
-                    commandLine.Append(" -fPIC ");
-                }
+            if (ConfigurationType == "DynamicLibrary")
+            {
+                commandLine.Append(" -fPIC");
             }
 
             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();
-        }
-
         private int Compile(string pathToTool)
         {
             if (Platform.Equals("pnacl", StringComparison.OrdinalIgnoreCase))
             {
                 if (!SDKUtilities.FindPython())
                 {
                     Log.LogError("PNaCl compilation requires python in your executable path.");
                     return -1;
                 }
 
@@ skipping 37 matching lines @@
             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());
+                    string commandLine = GenerateCommandLineForSource(sourceItem, true);
+                    commandLine += " " + GCCUtilities.ConvertPathWindowsToPosix(sourceItem.ToString());
 
                     if (OutputCommandLine)
                     {
                         string logMessage = pathToTool + " " + commandLine;
                         Log.LogMessage(logMessage);
                     }
                     else
                     {
                         base.Log.LogMessage(Path.GetFileName(sourceItem.ToString()));
                     }
@@ skipping 18 matching lines @@
         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);
+                string commandLine = GenerateCommandLineForSource(sourceItem);
                 if (srcGroups.ContainsKey(commandLine))
                 {
                     srcGroups[commandLine].Add(sourceItem);
                 }
                 else
                 {
                     srcGroups.Add(commandLine, new List<ITaskItem> {sourceItem});
                 }
             }
 
@@ skipping 46 matching lines @@
             {
                 returnCode = Compile(pathToTool);
             }
             finally
             {
 
             }
             return returnCode;
         }
 
-        protected void CalcSourcesToCompile()
+        protected override string GenerateResponseFileCommands()
         {
-            //check if full recompile is required otherwise perform incremental
-            if (this.ForcedRebuildRequired() || this.MinimalRebuildFromTracking == false)
-            {
-                this.CompileSourceList = this.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 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)
-            {
-                this.SkippedExecution = true;
-                return;
-            }
-
-            //remove sources to compile from tracked file list
-            this.TrackedInputFiles.RemoveEntriesForSource(this.CompileSourceList);
-            trackedOutputFiles.RemoveEntriesForSource(this.CompileSourceList);
-            this.TrackedInputFiles.SaveTlog();
-            trackedOutputFiles.SaveTlog();
+            return "";
         }
 
         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
-            {
-                xamlParser = new XamlParser(PropertiesFile);
-                if (!Setup())
-                    return false;
-                CalcSourcesToCompile();
-                returnResult = base.Execute();
-            }
-            finally
-            {
-
-            }
-
-            return returnResult;
-        }
-
-        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;
-
-                currentCommandLine.Append(GenerateCommandLineFromProps(sourceItem));
-                currentCommandLine.Append(" ");
-                currentCommandLine.Append(sourceItem.GetMetadata("FullPath").ToUpperInvariant());
-
-                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;
-        }
-
-        [Output]
-        public ITaskItem[] CompileSourceList
+        protected override string CommandTLogFilename
         {
             get
             {
-                return this.compileSourceList;
-            }
-            set
-            {
-                this.compileSourceList = value;
+                return BaseTool() + ".compile.command.1.tlog";
             }
         }
 
+        protected override string[] ReadTLogFilenames
+        {
+            get
+            {
+                return new string[] { BaseTool() + ".compile.read.1.tlog" };
+            }
+        }
+
+        protected override string WriteTLogFilename
+        {
+            get
+            {
+                return BaseTool() + ".compile.write.1.tlog";
+            }
+        }
+
         protected override string ToolName
         {
             get
             {
                 return NaCLCompilerPath;
             }
         }
 
     }
 }