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