msvc/mono.winconfig.targets

   1 <?xml version="1.0" encoding="utf-8"?>
   2 <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   3
   4     <UsingTask TaskName="WinConfigSetup" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">
   5       <ParameterGroup>
   6         <ConfigFileRoot ParameterType="System.String" Required="true" />
   7         <DisableDefines ParameterType="System.String" Required="false" />
   8         <EnableDefines ParameterType="System.String" Required="false" />
   9         <HaveDefines ParameterType="System.String" Required="false" />
  10       </ParameterGroup>
  11         <Task>
  12             <Code Type="Class" Language="cs">
  13             <![CDATA[
  14                 using System;
  15                 using System.IO;
  16                 using System.Text;
  17                 using System.Linq;
  18                 using Microsoft.Build.Framework;
  19                 using Microsoft.Build.Utilities;
  20                 using System.Collections.Generic;
  21                 using System.Text.RegularExpressions;
  22
  23                 public class _WinConfigSetup : Task
  24                 {
  25                   bool GetVersionsFromConfigureAC (string configureACFile, out string monoVersion, out string monoCorlibVersion)
  26                   {
  27                       bool result = true;
  28                       monoVersion = null;
  29                       monoCorlibVersion = null;
  30                       if (File.Exists (configureACFile))
  31                       {
  32                           // These are both fairly arbitrary strings.
  33                           var monoVersionRegEx = new Regex (@"^AC_INIT\s*\(\s*mono,\s*\[?\s*([^\],\s]+)");
  34                           var monoCorlibVersionRegEx = new Regex (@"^MONO_CORLIB_VERSION\s*=\s*(\S+)");
  35                           using (StreamReader reader = new StreamReader (configureACFile))
  36                           {
  37                               string line;
  38                               while ((line = reader.ReadLine ()) != null && (monoVersion == null || monoCorlibVersion == null))
  39                               {
  40                                   var monoVersionMatch = monoVersionRegEx.Match (line);
  41                                   if (monoVersionMatch.Success)
  42                                   {
  43                                       if (monoVersion != null)
  44                                       {
  45                                           Log.LogError("duplicate MONO_INIT in {0}", configureACFile);
  46                                           result = false;
  47                                       }
  48                                       monoVersion = monoVersionMatch.Groups[1].Value;
  49                                       Log.LogMessage ("{0}:AC_INIT:MONO_VERSION=\"{1}\"", configureACFile, monoVersion);
  50                                       continue;
  51                                   }
  52
  53                                   var monoCorlibVersionMatch = monoCorlibVersionRegEx.Match (line);
  54                                   if (monoCorlibVersionMatch.Success)
  55                                   {
  56                                       if (monoCorlibVersion != null)
  57                                       {
  58                                           // This is misleading. The loop stops when both found, so duplicates usually not noticed.
  59                                           Log.LogError("duplicate MONO_CORLIB_VERSION in {0}", configureACFile);
  60                                           result = false;
  61                                       }
  62                                       monoCorlibVersion = monoCorlibVersionMatch.Groups[1].Value;
  63                                       Log.LogMessage ("{0}:MONO_CORLIB_VERSION=\"{1}\"", configureACFile, monoCorlibVersion);
  64                                       continue;
  65                                   }
  66                               }
  67                           }
  68                       }
  69                       return result;
  70                   }
  71
  72                   List<string> GetConfigFeatures (string path, string featuresRegex)
  73                   {
  74                       var features = new List<string> ();
  75                       if (File.Exists (path))
  76                       {
  77                           var regex = new Regex (featuresRegex);
  78                           using (StreamReader reader = new StreamReader (path))
  79                           {
  80                               string line;
  81                               while ((line = reader.ReadLine ()) != null)
  82                               {
  83                                   var match = regex.Match (line);
  84                                   if (match != null && match.Success)
  85                                   {
  86                                       if (match.Groups != null && match.Groups.Count == 1)
  87                                       {
  88                                           var configLine = match.Groups[0].ToString ();
  89                                           if (!String.IsNullOrEmpty (configLine))
  90                                           {
  91                                               var configItems = configLine.Trim ().Split (' ');
  92                                               if (configItems != null && configItems.Length == 3)
  93                                               {
  94                                                   // Second item should be the define.
  95                                                   features.Add (configItems[1]);
  96                                               }
  97                                           }
  98                                       }
  99                                   }
 100                               }
 101                           }
 102                       }
 103                       return features;
 104                   }
 105
 106                   string [] GetEnabledConfigFeatures (string path, string enableDefines)
 107                   {
 108                       string [] supportedFeatures = { "ENABLE_ICALL_SYMBOL_MAP",
 109                                                       "ENABLE_LLVM",
 110                                                       "ENABLE_LLVM_RUNTIME",
 111                                                       "ENABLE_HYBRID_SUSPEND",
 112                                                       "ENABLE_COOP_SUSPEND" };
 113
 114                       var enableFeatures = GetConfigFeatures(path, ".*#define.*ENABLE_.*1");
 115                       if (enableDefines != null)
 116                           enableFeatures.AddRange (enableDefines.Split (';'));
 117
 118                       // Only keep supported features on Windows platforms using MSVC.
 119                       var features = new List<string> ();
 120                       foreach (var feature in enableFeatures)
 121                           if (Array.Exists(supportedFeatures, s => String.CompareOrdinal (s,feature) == 0))
 122                               features.Add(feature);
 123                       return features.ToArray ();
 124                   }
 125
 126                   string [] GetDisabledConfigFeatures (string path)
 127                   {
 128                       return GetConfigFeatures(path, ".*#define.*DISABLE_.*1").ToArray ();
 129                   }
 130
 131                   void CreateConfigUsingTemplate (string templatePath, string targetPath, string [] disabledDefines, string [] enabledDefines, string [] haveDefines, string monoVersion, string monoCorlibVersion)
 132                   {
 133                       string tempFilePath = "";
 134
 135                       try
 136                       {
 137                           if (File.Exists (templatePath))
 138                           {
 139                               var disabledDefinesRegex = new Regex (".*@DISABLE_DEFINES@.*");
 140                               var enabledDefinesRegex = new Regex (".*@ENABLE_DEFINES@.*");
 141                               var haveDefinesRegex = new Regex (".*@HAVE_DEFINES.*");
 142
 143                               var definesList = new List<Tuple<Regex, string []>>
 144                               {
 145                                   new Tuple<Regex, string []>(disabledDefinesRegex, disabledDefines),
 146                                   new Tuple<Regex, string []>(enabledDefinesRegex, enabledDefines),
 147                                   new Tuple<Regex, string []>(haveDefinesRegex, haveDefines)
 148                               };
 149
 150                               var monoCorlibVersions = new string [] {
 151                                   ".*#MONO_CORLIB_VERSION#.*",
 152                                   "#MONO_CORLIB_VERSION#",
 153                                   monoCorlibVersion
 154                               };
 155                               var monoCorlibVersionRegex = new Regex (monoCorlibVersions[0]);
 156
 157                               var monoVersions = new string [] {
 158                                   ".*#MONO_VERSION#.*",
 159                                   "#MONO_VERSION#",
 160                                   monoVersion
 161                               };
 162                               var monoVersionRegex = new Regex (monoVersions[0]);
 163
 164                               var versionList = new List<Tuple<Regex, string []>>
 165                               {
 166                                   new Tuple<Regex, string []>(monoCorlibVersionRegex, monoCorlibVersions),
 167                                   new Tuple<Regex, string []>(monoVersionRegex, monoVersions)
 168                               };
 169
 170                               tempFilePath = Path.GetTempFileName ();
 171
 172                               using (StreamReader reader = new StreamReader (templatePath))
 173                               using (StreamWriter writer = new StreamWriter (tempFilePath))
 174                               {
 175                                   string line;
 176                                   Match match;
 177                                   while ((line = reader.ReadLine ()) != null)
 178                                   {
 179                                       var replaced = false;
 180                                       foreach (var defines in definesList)
 181                                       {
 182                                           match = defines.Item1.Match (line);
 183                                           if (match != null && match.Success && defines.Item2 != null)
 184                                           {
 185                                               // Replace with disabled defines.
 186                                               foreach (var define in defines.Item2)
 187                                               {
 188                                                   writer.WriteLine ("#ifndef {0}", define);
 189                                                   writer.WriteLine ("#define {0} 1", define);
 190                                                   writer.WriteLine ("#endif");
 191                                               }
 192                                               replaced = true;
 193                                               break;
 194                                           }
 195                                       }
 196
 197                                       if (!replaced)
 198                                       {
 199                                           foreach (var version in versionList)
 200                                           {
 201                                               match = version.Item1.Match (line);
 202                                               if (match != null && match.Success)
 203                                               {
 204                                                   writer.WriteLine (line.Replace(version.Item2[1], version.Item2[2]));
 205                                                   replaced = true;
 206                                                   break;
 207                                               }
 208                                           }
 209                                       }
 210
 211                                       if (!replaced)
 212                                           writer.WriteLine (line);
 213                                   }
 214                               }
 215
 216                               bool overwrite = true;
 217                               if (File.Exists (targetPath))
 218                               {
 219                                   if (File.ReadAllBytes (tempFilePath).SequenceEqual (File.ReadAllBytes (targetPath)))
 220                                       overwrite = false;
 221                               }
 222
 223                               if (overwrite)
 224                                   File.Copy (tempFilePath, targetPath, true);
 225                           }
 226                       }
 227                       finally
 228                       {
 229                           if (!String.IsNullOrEmpty (tempFilePath))
 230                               File.Delete (tempFilePath);
 231                       }
 232                   }
 233
 234                   void CreateVersionFile (string targetFile)
 235                   {
 236                       string tempFile = "";
 237
 238                       try
 239                       {
 240                           tempFile = Path.GetTempFileName ();
 241
 242                           using (StreamWriter writer = new StreamWriter (tempFile))
 243                           {
 244                               writer.WriteLine ("#define FULL_VERSION \"Visual Studio built mono\"");
 245                           }
 246
 247                           bool overwrite = true;
 248                           if (File.Exists (targetFile))
 249                           {
 250                               if (File.ReadAllBytes (tempFile).SequenceEqual (File.ReadAllBytes (targetFile)))
 251                                   overwrite = false;
 252                           }
 253
 254                           if (overwrite)
 255                               File.Copy (tempFile, targetFile, true);
 256                       }
 257                       finally
 258                       {
 259                           if (!String.IsNullOrEmpty (tempFile))
 260                               File.Delete (tempFile);
 261                       }
 262                   }
 263
 264                   bool BackupConfigFile (string sourceConfigFile, string targetConfigFile)
 265                   {
 266                       bool result = false;
 267                       if (File.Exists (sourceConfigFile))
 268                       {
 269                           var includesCygconfig = new Regex (".*#include \"cygconfig.h\".*");
 270
 271                           var allText = File.ReadAllText (sourceConfigFile);
 272                           var match = includesCygconfig.Match (allText);
 273                           if (match == null || !match.Success)
 274                           {
 275                               File.Copy (sourceConfigFile, targetConfigFile, true);
 276                               result = true;
 277                           }
 278                       }
 279
 280                       return result;
 281                   }
 282
 283                   public string ConfigFileRoot { get; set; }
 284                   public string DisableDefines { get; set; }
 285                   public string EnableDefines { get; set; }
 286                   public string HaveDefines { get; set; }
 287
 288                   public override bool Execute ()
 289                   {
 290                     string configureACFile = Path.Combine (ConfigFileRoot, @"configure.ac");
 291                     string configFile = Path.Combine (ConfigFileRoot, @"config.h");
 292                     string cygConfigFile = Path.Combine (ConfigFileRoot, @"cygconfig.h");
 293                     string winConfigFile = Path.Combine (ConfigFileRoot, @"winconfig.h");
 294                     string versionFile = Path.Combine (ConfigFileRoot, @"mono\mini\version.h");
 295
 296                     Log.LogMessage (MessageImportance.High, "Setting up Mono configuration headers...");
 297
 298                     BackupConfigFile (configFile, cygConfigFile);
 299
 300                     string monoVersion = null;
 301                     string monoCorlibVersion = null;
 302                     if (!GetVersionsFromConfigureAC (configureACFile, out monoVersion, out monoCorlibVersion))
 303                         return false;
 304
 305                     if (monoVersion == null)
 306                     {
 307                         Log.LogError("failed to parse version from AC_INIT in {0}", configureACFile);
 308                         return false;
 309                     }
 310
 311                     if (monoCorlibVersion == null)
 312                     {
 313                         Log.LogError("failed to parse MONO_CORLIB_VERSION from {0}", configureACFile);
 314                         return false;
 315                     }
 316
 317                     var disableDefines = GetDisabledConfigFeatures (cygConfigFile);
 318                     var enableDefines = GetEnabledConfigFeatures (cygConfigFile, EnableDefines);
 319                     var haveDefines = (HaveDefines != null) ? HaveDefines.Split (';') : null;
 320                     CreateConfigUsingTemplate (winConfigFile, configFile, disableDefines, enableDefines, haveDefines, monoVersion, monoCorlibVersion);
 321
 322                     CreateVersionFile (versionFile);
 323
 324                     Log.LogMessage (MessageImportance.High, "Successfully setup Mono configuration headers {0} and {1} from {2}.", configFile, versionFile, winConfigFile);
 325
 326                     return true;
 327                   }
 328                 }
 329             ]]>
 330             </Code>
 331         </Task>
 332     </UsingTask>
 333
 334     <Target Name="RunWinConfigSetup">
 335       <WinConfigSetup ConfigFileRoot="$(MSBuildThisFileDirectory)..\"
 336                        DisableDefines=""
 337                        EnableDefines=""
 338                        HaveDefines=""/>
 339     </Target>
 340
 341 </Project>