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                   void GetVersionsFromConfigureAC (string configureACFile, out string monoVersion, out string monoCorlibVersion)
  26                   {
  27                       monoVersion = null;
  28                       monoCorlibVersion = null;
  29                       if (File.Exists (configureACFile))
  30                       {
  31                           var monoVersionRegEx = new Regex (@"(.*AC_INIT\(mono, \[)(\d+\.\d+\.\d+)");
  32                           var monoCorlibVersionRegEx = new Regex (@"(MONO_CORLIB_VERSION=)([A-F0-9]{8}(?:-[A-F0-9]{4}){3}-[A-F0-9]{12})");
  33                           using (StreamReader reader = new StreamReader (configureACFile))
  34                           {
  35                               string line;
  36                               while ((line = reader.ReadLine ()) != null && (monoVersion == null || monoCorlibVersion == null))
  37                               {
  38                                   var monoVersionMatch = monoVersionRegEx.Match (line);
  39                                   if (monoVersionMatch != null && monoVersionMatch.Success && monoVersionMatch.Groups.Count == 3)
  40                                   {
  41                                       monoVersion = monoVersionMatch.Groups[2].Value;
  42                                       continue;
  43                                   }
  44
  45                                   var monoCorlibVersionMatch = monoCorlibVersionRegEx.Match (line);
  46                                   if (monoCorlibVersionMatch != null && monoCorlibVersionMatch.Success && monoCorlibVersionMatch.Groups.Count == 3)
  47                                   {
  48                                       monoCorlibVersion = monoCorlibVersionMatch.Groups[2].Value;
  49                                       continue;
  50                                   }
  51                               }
  52                           }
  53                       }
  54                   }
  55
  56                   string [] GetDisabledConfigFeatures (string path)
  57                   {
  58                       var disabledFeatures = new List<string> ();
  59                       if (File.Exists (path))
  60                       {
  61                           var regex = new Regex (".*#define.*DISABLE_.*1");
  62                           using (StreamReader reader = new StreamReader (path))
  63                           {
  64                               string line;
  65                               while ((line = reader.ReadLine ()) != null)
  66                               {
  67                                   var match = regex.Match (line);
  68                                   if (match != null && match.Success)
  69                                   {
  70                                       if (match.Groups != null && match.Groups.Count == 1)
  71                                       {
  72                                           var configLine = match.Groups[0].ToString ();
  73                                           if (!String.IsNullOrEmpty (configLine))
  74                                           {
  75                                               var configItems = configLine.Trim ().Split (' ');
  76                                               if (configItems != null && configItems.Length == 3)
  77                                               {
  78                                                   // Second item should be the define.
  79                                                   disabledFeatures.Add (configItems[1]);
  80                                               }
  81                                           }
  82                                       }
  83                                   }
  84                               }
  85                           }
  86                       }
  87                       return disabledFeatures.ToArray ();
  88                   }
  89
  90                   void CreateConfigUsingTemplate (string templatePath, string targetPath, string [] disabledDefines, string [] enabledDefines, string [] haveDefines, string monoVersion, string monoCorlibVersion)
  91                   {
  92                       string tempFilePath = "";
  93
  94                       try
  95                       {
  96                           if (File.Exists (templatePath))
  97                           {
  98                               var disabledDefinesRegex = new Regex (".*@DISABLE_DEFINES@.*");
  99                               var enabledDefinesRegex = new Regex (".*@ENABLE_DEFINES@.*");
 100                               var haveDefinesRegex = new Regex (".*@HAVE_DEFINES.*");
 101
 102                               var definesList = new List<Tuple<Regex, string []>>
 103                               {
 104                                   new Tuple<Regex, string []>(disabledDefinesRegex, disabledDefines),
 105                                   new Tuple<Regex, string []>(enabledDefinesRegex, enabledDefines),
 106                                   new Tuple<Regex, string []>(haveDefinesRegex, haveDefines)
 107                               };
 108
 109                               var monoCorlibVersions = new string [] {
 110                                   ".*#MONO_CORLIB_VERSION#.*",
 111                                   "#MONO_CORLIB_VERSION#",
 112                                   monoCorlibVersion
 113                               };
 114                               var monoCorlibVersionRegex = new Regex (monoCorlibVersions[0]);
 115
 116                               var monoVersions = new string [] {
 117                                   ".*#MONO_VERSION#.*",
 118                                   "#MONO_VERSION#",
 119                                   monoVersion
 120                               };
 121                               var monoVersionRegex = new Regex (monoVersions[0]);
 122
 123                               var versionList = new List<Tuple<Regex, string []>>
 124                               {
 125                                   new Tuple<Regex, string []>(monoCorlibVersionRegex, monoCorlibVersions),
 126                                   new Tuple<Regex, string []>(monoVersionRegex, monoVersions)
 127                               };
 128
 129                               tempFilePath = Path.GetTempFileName ();
 130
 131                               using (StreamReader reader = new StreamReader (templatePath))
 132                               using (StreamWriter writer = new StreamWriter (tempFilePath))
 133                               {
 134                                   string line;
 135                                   Match match;
 136                                   while ((line = reader.ReadLine ()) != null)
 137                                   {
 138                                       var replaced = false;
 139                                       foreach (var defines in definesList)
 140                                       {
 141                                           match = defines.Item1.Match (line);
 142                                           if (match != null && match.Success && defines.Item2 != null)
 143                                           {
 144                                               // Replace with disabled defines.
 145                                               foreach (var define in defines.Item2)
 146                                               {
 147                                                   writer.WriteLine ("#ifndef {0}", define);
 148                                                   writer.WriteLine ("#define {0} 1", define);
 149                                                   writer.WriteLine ("#endif");
 150                                               }
 151                                               replaced = true;
 152                                               break;
 153                                           }
 154                                       }
 155
 156                                       if (!replaced)
 157                                       {
 158                                           foreach (var version in versionList)
 159                                           {
 160                                               match = version.Item1.Match (line);
 161                                               if (match != null && match.Success)
 162                                               {
 163                                                   writer.WriteLine (line.Replace(version.Item2[1], version.Item2[2]));
 164                                                   replaced = true;
 165                                                   break;
 166                                               }
 167                                           }
 168                                       }
 169
 170                                       if (!replaced)
 171                                           writer.WriteLine (line);
 172                                   }
 173                               }
 174
 175                               bool overwrite = true;
 176                               if (File.Exists (targetPath))
 177                               {
 178                                   if (File.ReadAllBytes (tempFilePath).SequenceEqual (File.ReadAllBytes (targetPath)))
 179                                       overwrite = false;
 180                               }
 181
 182                               if (overwrite)
 183                                   File.Copy (tempFilePath, targetPath, true);
 184                           }
 185                       }
 186                       finally
 187                       {
 188                           if (!String.IsNullOrEmpty (tempFilePath))
 189                               File.Delete (tempFilePath);
 190                       }
 191                   }
 192
 193                   void CreateVersionFile (string targetFile)
 194                   {
 195                       string tempFile = "";
 196
 197                       try
 198                       {
 199                           tempFile = Path.GetTempFileName ();
 200
 201                           using (StreamWriter writer = new StreamWriter (tempFile))
 202                           {
 203                               writer.WriteLine ("#define FULL_VERSION \"Visual Studio built mono\"");
 204                           }
 205
 206                           bool overwrite = true;
 207                           if (File.Exists (targetFile))
 208                           {
 209                               if (File.ReadAllBytes (tempFile).SequenceEqual (File.ReadAllBytes (targetFile)))
 210                                   overwrite = false;
 211                           }
 212
 213                           if (overwrite)
 214                               File.Copy (tempFile, targetFile, true);
 215                       }
 216                       finally
 217                       {
 218                           if (!String.IsNullOrEmpty (tempFile))
 219                               File.Delete (tempFile);
 220                       }
 221                   }
 222
 223                   bool BackupConfigFile (string sourceConfigFile, string targetConfigFile)
 224                   {
 225                       bool result = false;
 226                       if (File.Exists (sourceConfigFile))
 227                       {
 228                           var includesCygconfig = new Regex (".*#include \"cygconfig.h\".*");
 229
 230                           var allText = File.ReadAllText (sourceConfigFile);
 231                           var match = includesCygconfig.Match (allText);
 232                           if (match == null || !match.Success)
 233                           {
 234                               File.Copy (sourceConfigFile, targetConfigFile, true);
 235                               result = true;
 236                           }
 237                       }
 238
 239                       return result;
 240                   }
 241
 242                   public string ConfigFileRoot { get; set; }
 243                   public string DisableDefines { get; set; }
 244                   public string EnableDefines { get; set; }
 245                   public string HaveDefines { get; set; }
 246
 247                   public override bool Execute ()
 248                   {
 249                     string configureACFile = Path.Combine (ConfigFileRoot, @"configure.ac");
 250                     string configFile = Path.Combine (ConfigFileRoot, @"config.h");
 251                     string cygConfigFile = Path.Combine (ConfigFileRoot, @"cygconfig.h");
 252                     string winConfigFile = Path.Combine (ConfigFileRoot, @"winconfig.h");
 253                     string versionFile = Path.Combine (ConfigFileRoot, @"mono\mini\version.h");
 254
 255                     Log.LogMessage (MessageImportance.High, "Setting up Mono configuration headers...");
 256
 257                     BackupConfigFile (configFile, cygConfigFile);
 258
 259                     string monoVersion = null;
 260                     string monoCorlibVersion = null;
 261                     GetVersionsFromConfigureAC (configureACFile, out monoVersion, out monoCorlibVersion);
 262
 263                     var disableDefines = GetDisabledConfigFeatures (cygConfigFile);
 264                     var enableDefines = (EnableDefines != null) ? EnableDefines.Split (';') : null;
 265                     var haveDefines = (HaveDefines != null) ? HaveDefines.Split (';') : null;
 266                     CreateConfigUsingTemplate (winConfigFile, configFile, disableDefines, enableDefines, haveDefines, monoVersion, monoCorlibVersion);
 267
 268                     CreateVersionFile (versionFile);
 269
 270                     Log.LogMessage (MessageImportance.High, "Successfully setup Mono configuration headers.");
 271
 272                     return true;
 273                   }
 274                 }
 275             ]]>
 276             </Code>
 277         </Task>
 278     </UsingTask>
 279
 280     <Target Name="RunWinConfigSetup">
 281       <WinConfigSetup ConfigFileRoot="$(MSBuildThisFileDirectory)..\"
 282                        DisableDefines=""
 283                        EnableDefines=""
 284                        HaveDefines=""/>
 285     </Target>
 286
 287 </Project>