[NaCl Addin] Fix to PNaCl lib creation from MSVS

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;
 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 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;
 
-        protected abstract CanonicalTrackedOutputFiles OutputWriteTLog(ITaskItem[] compiledSources);
-        protected abstract void OutputReadTLog(ITaskItem[] compiledSources, CanonicalTrackedOutputFiles outputs);
-        protected abstract void OutputCommandTLog(ITaskItem[] compiledSources);
-
         [Required]
         public string TrackerLogDirectory { get; set; }
 
         [Required]
         public virtual ITaskItem[] Sources { get; set; }
 
+        [Required]
+        public bool OutputCommandLine { 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; }
         }
 
         protected bool ForcedRebuildRequired()
         {
@@ skipping 25 matching lines @@
         protected override bool SkipTaskExecution()
         {
             return this.skippedExecution;
         }
 
         protected string BaseTool()
         {
             return Path.GetFileNameWithoutExtension(ToolName);
         }
 
+        protected bool IsPNaCl()
+        {
+            return Platform.Equals("pnacl", StringComparison.OrdinalIgnoreCase);
+        }
+
         protected bool Setup()
         {
             this.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)
             {
                 this.SetTrackerLogPaths();
             }
 
             if (this.ForcedRebuildRequired() || this.MinimalRebuildFromTracking == false)
             {
                 if (this.Sources == null || this.Sources.Length == 0)
                 {
                     this.SkippedExecution = true;
                 }
             }
 
             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 });
+
+            foreach (ITaskItem sourceItem in Sources)
+            {
+                //remove this entry associated with compiled source which is about to be recomputed
+                trackedFiles.RemoveEntriesForSource(sourceItem);
+
+                //add entry with updated information
+                string upper = Path.GetFullPath(sourceItem.ItemSpec).ToUpperInvariant();
+                trackedFiles.AddComputedOutputForSourceRoot(upper, OutputFile);
+            }
+
+            //output tlog
+            trackedFiles.SaveTlog();
+
+            return trackedFiles;
+        }
+
+        protected virtual void OutputReadTLog(ITaskItem[] compiledSources,
+                                              CanonicalTrackedOutputFiles outputs)
+        {
+            string trackerPath = Path.GetFullPath(TlogDirectory + ReadTLogFilenames[0]);
+
+            using (var writer = new StreamWriter(trackerPath, false, Encoding.Unicode))
+            {
+                string sourcePath = "";
+                foreach (ITaskItem source in Sources)
+                {
+                    if (sourcePath != "")
+                        sourcePath += "|";
+                    sourcePath += Path.GetFullPath(source.ItemSpec).ToUpperInvariant();
+                }
+
+                writer.WriteLine("^" + sourcePath);
+                foreach (ITaskItem source in Sources)
+                {
+                    writer.WriteLine(Path.GetFullPath(source.ItemSpec).ToUpperInvariant());
+                }
+                writer.WriteLine(Path.GetFullPath(OutputFile).ToUpperInvariant());
+            }
+        }
+
+        protected virtual void OutputCommandTLog(ITaskItem[] compiledSources)
+        {
+            string fullpath = TLogCommandFile.GetMetadata("FullPath");
+            using (var writer = new StreamWriter(fullpath, false, Encoding.Unicode))
+            {
+                string cmds = GenerateResponseFileCommands();
+                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();
 
             // Update tracker log files if execution occurred
             //if (this.skippedExecution == false)
             {
                 CanonicalTrackedOutputFiles outputs = OutputWriteTLog(compileSourceList);
                 OutputReadTLog(compileSourceList, outputs);
                 OutputCommandTLog(compileSourceList);
@@ skipping 162 matching lines @@
             }
         }
 
         protected virtual string WriteTLogFilename
         {
             get
             {
                 return BaseTool() + ".compile.write.1.tlog";
             }
         }
+
+        public virtual string PlatformToolset
+        {
+            get
+            {
+                return "GCC";
+            }
+        }
+
+        protected override string GenerateFullPathToTool()
+        {
+            return this.ToolName;
+        }
     }
 }