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                                                       "ENABLE_NETCORE" };
 114
 115                       var enableFeatures = GetConfigFeatures(path, ".*#define.*ENABLE_.*1");
 116                       if (enableDefines != null)
 117                           enableFeatures.AddRange (enableDefines.Split (';'));
 118
 119                       // Only keep supported features on Windows platforms using MSVC.
 120                       var features = new List<string> ();
 121                       foreach (var feature in enableFeatures)
 122                           if (Array.Exists(supportedFeatures, s => String.CompareOrdinal (s,feature) == 0))
 123                               features.Add(feature);
 124                       return features.ToArray ();
 125                   }
 126
 127                   string [] GetDisabledConfigFeatures (string path)
 128                   {
 129                       return GetConfigFeatures(path, ".*#define.*DISABLE_.*1").ToArray ();
 130                   }
 131
 132                   void CreateConfigUsingTemplate (string templatePath, string targetPath, string [] disabledDefines, string [] enabledDefines, string [] haveDefines, string monoVersion, string monoCorlibVersion)
 133                   {
 134                       string tempFilePath = "";
 135
 136                       try
 137                       {
 138                           if (File.Exists (templatePath))
 139                           {
 140                               var disabledDefinesRegex = new Regex (".*@DISABLE_DEFINES@.*");
 141                               var enabledDefinesRegex = new Regex (".*@ENABLE_DEFINES@.*");
 142                               var haveDefinesRegex = new Regex (".*@HAVE_DEFINES.*");
 143
 144                               var definesList = new List<Tuple<Regex, string []>>
 145                               {
 146                                   new Tuple<Regex, string []>(disabledDefinesRegex, disabledDefines),
 147                                   new Tuple<Regex, string []>(enabledDefinesRegex, enabledDefines),
 148                                   new Tuple<Regex, string []>(haveDefinesRegex, haveDefines)
 149                               };
 150
 151                               var monoCorlibVersions = new string [] {
 152                                   ".*#MONO_CORLIB_VERSION#.*",
 153                                   "#MONO_CORLIB_VERSION#",
 154                                   monoCorlibVersion
 155                               };
 156                               var monoCorlibVersionRegex = new Regex (monoCorlibVersions[0]);
 157
 158                               var monoVersions = new string [] {
 159                                   ".*#MONO_VERSION#.*",
 160                                   "#MONO_VERSION#",
 161                                   monoVersion
 162                               };
 163                               var monoVersionRegex = new Regex (monoVersions[0]);
 164
 165                               var versionList = new List<Tuple<Regex, string []>>
 166                               {
 167                                   new Tuple<Regex, string []>(monoCorlibVersionRegex, monoCorlibVersions),
 168                                   new Tuple<Regex, string []>(monoVersionRegex, monoVersions)
 169                               };
 170
 171                               tempFilePath = Path.GetTempFileName ();
 172
 173                               using (StreamReader reader = new StreamReader (templatePath))
 174                               using (StreamWriter writer = new StreamWriter (tempFilePath))
 175                               {
 176                                   string line;
 177                                   Match match;
 178                                   while ((line = reader.ReadLine ()) != null)
 179                                   {
 180                                       var replaced = false;
 181                                       foreach (var defines in definesList)
 182                                       {
 183                                           match = defines.Item1.Match (line);
 184                                           if (match != null && match.Success && defines.Item2 != null)
 185                                           {
 186                                               // Replace with disabled defines.
 187                                               foreach (var define in defines.Item2)
 188                                               {
 189                                                   writer.WriteLine ("#ifndef {0}", define);
 190                                                   writer.WriteLine ("#define {0} 1", define);
 191                                                   writer.WriteLine ("#endif");
 192                                               }
 193                                               replaced = true;
 194                                               break;
 195                                           }
 196                                       }
 197
 198                                       if (!replaced)
 199                                       {
 200                                           foreach (var version in versionList)
 201                                           {
 202                                               match = version.Item1.Match (line);
 203                                               if (match != null && match.Success)
 204                                               {
 205                                                   writer.WriteLine (line.Replace(version.Item2[1], version.Item2[2]));
 206                                                   replaced = true;
 207                                                   break;
 208                                               }
 209                                           }
 210                                       }
 211
 212                                       if (!replaced)
 213                                           writer.WriteLine (line);
 214                                   }
 215                               }
 216
 217                               bool overwrite = true;
 218                               if (File.Exists (targetPath))
 219                               {
 220                                   if (File.ReadAllBytes (tempFilePath).SequenceEqual (File.ReadAllBytes (targetPath)))
 221                                       overwrite = false;
 222                               }
 223
 224                               if (overwrite)
 225                                   File.Copy (tempFilePath, targetPath, true);
 226                           }
 227                       }
 228                       finally
 229                       {
 230                           if (!String.IsNullOrEmpty (tempFilePath))
 231                               File.Delete (tempFilePath);
 232                       }
 233                   }
 234
 235                   void CreateVersionFile (string targetFile)
 236                   {
 237                       string tempFile = "";
 238
 239                       try
 240                       {
 241                           tempFile = Path.GetTempFileName ();
 242
 243                           using (StreamWriter writer = new StreamWriter (tempFile))
 244                           {
 245                               writer.WriteLine ("#define FULL_VERSION \"Visual Studio built mono\"");
 246                           }
 247
 248                           bool overwrite = true;
 249                           if (File.Exists (targetFile))
 250                           {
 251                               if (File.ReadAllBytes (tempFile).SequenceEqual (File.ReadAllBytes (targetFile)))
 252                                   overwrite = false;
 253                           }
 254
 255                           if (overwrite)
 256                               File.Copy (tempFile, targetFile, true);
 257                       }
 258                       finally
 259                       {
 260                           if (!String.IsNullOrEmpty (tempFile))
 261                               File.Delete (tempFile);
 262                       }
 263                   }
 264
 265                   bool BackupConfigFile (string sourceConfigFile, string targetConfigFile)
 266                   {
 267                       bool result = false;
 268                       if (File.Exists (sourceConfigFile))
 269                       {
 270                           var includesCygconfig = new Regex (".*#include \"cygconfig.h\".*");
 271
 272                           var allText = File.ReadAllText (sourceConfigFile);
 273                           var match = includesCygconfig.Match (allText);
 274                           if (match == null || !match.Success)
 275                           {
 276                               File.Copy (sourceConfigFile, targetConfigFile, true);
 277                               result = true;
 278                           }
 279                       }
 280
 281                       return result;
 282                   }
 283
 284                   public string ConfigFileRoot { get; set; }
 285                   public string DisableDefines { get; set; }
 286                   public string EnableDefines { get; set; }
 287                   public string HaveDefines { get; set; }
 288
 289                   public override bool Execute ()
 290                   {
 291                     string configureACFile = Path.Combine (ConfigFileRoot, @"configure.ac");
 292                     string configFile = Path.Combine (ConfigFileRoot, @"config.h");
 293                     string cygConfigFile = Path.Combine (ConfigFileRoot, @"cygconfig.h");
 294                     string winConfigFile = Path.Combine (ConfigFileRoot, @"winconfig.h");
 295                     string versionFile = Path.Combine (ConfigFileRoot, @"mono\mini\version.h");
 296
 297                     Log.LogMessage (MessageImportance.High, "Setting up Mono configuration headers...");
 298
 299                     BackupConfigFile (configFile, cygConfigFile);
 300
 301                     string monoVersion = null;
 302                     string monoCorlibVersion = null;
 303                     if (!GetVersionsFromConfigureAC (configureACFile, out monoVersion, out monoCorlibVersion))
 304                         return false;
 305
 306                     if (monoVersion == null)
 307                     {
 308                         Log.LogError("failed to parse version from AC_INIT in {0}", configureACFile);
 309                         return false;
 310                     }
 311
 312                     if (monoCorlibVersion == null)
 313                     {
 314                         Log.LogError("failed to parse MONO_CORLIB_VERSION from {0}", configureACFile);
 315                         return false;
 316                     }
 317
 318                     var disableDefines = GetDisabledConfigFeatures (cygConfigFile);
 319                     var enableDefines = GetEnabledConfigFeatures (cygConfigFile, EnableDefines);
 320                     var haveDefines = (HaveDefines != null) ? HaveDefines.Split (';') : null;
 321                     CreateConfigUsingTemplate (winConfigFile, configFile, disableDefines, enableDefines, haveDefines, monoVersion, monoCorlibVersion);
 322
 323                     CreateVersionFile (versionFile);
 324
 325                     Log.LogMessage (MessageImportance.High, "Successfully setup Mono configuration headers {0} and {1} from {2}.", configFile, versionFile, winConfigFile);
 326
 327                     return true;
 328                   }
 329                 }
 330             ]]>
 331             </Code>
 332         </Task>
 333     </UsingTask>
 334
 335     <Target Name="RunWinConfigSetup">
 336       <WinConfigSetup ConfigFileRoot="$(MSBuildThisFileDirectory)..\"
 337                        DisableDefines=""
 338                        EnableDefines=""
 339                        HaveDefines=""/>
 340     </Target>
 341
 342 </Project>