msvc/scripts/genproj.cs

   1 //
   2 // Consumes the order.xml file that contains a list of all the assemblies to build
   3 // and produces a solution and the csproj files for it
   4 //
   5 // Currently this hardcodes a set of assemblies to build, the net-4.x series, but
   6 // it can be extended to handle the command line tools.
   7 //
   8 // KNOWN ISSUES:
   9 //    * This fails to find matches for "System" and "System.xml" when processing the
  10 //      RabbitMQ executable, likely, because we do not process executables yet
  11 //
  12 //    * Has not been tested in a while with the command line tools
  13 //
  14 using System;
  15 using System.IO;
  16 using System.Collections.Generic;
  17 using System.Text;
  18 using System.Globalization;
  19 using System.Xml.Linq;
  20 using System.Xml.XPath;
  21 using System.Linq;
  22 using System.Xml;
  23
  24 public enum Target {
  25         Library, Exe, Module, WinExe
  26 }
  27
  28 public enum LanguageVersion {
  29         ISO_1 = 1,
  30         Default_MCS = 2,
  31         ISO_2 = 3,
  32         LINQ = 4,
  33         Future = 5,
  34         Default = LINQ
  35 }
  36
  37 class SlnGenerator {
  38         public static readonly string NewLine = "\r\n"; //Environment.NewLine; // "\n";
  39         public SlnGenerator (string formatVersion = "2012")
  40         {
  41                 switch (formatVersion) {
  42                 case "2008":
  43                         this.header = MakeHeader ("10.00", "2008");
  44                         break;
  45                 default:
  46                         this.header = MakeHeader ("12.00", "2012");
  47                         break;
  48                 }
  49         }
  50
  51         const string project_start = "Project(\"{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}\") = \"{0}\", \"{1}\", \"{2}\""; // Note: No need to double up on {} around {2}
  52         const string project_end = "EndProject";
  53
  54         public List<MsbuildGenerator.VsCsproj> libraries = new List<MsbuildGenerator.VsCsproj> ();
  55         string header;
  56
  57         string MakeHeader (string formatVersion, string yearTag)
  58         {
  59                 return string.Format ("Microsoft Visual Studio Solution File, Format Version {0}" + NewLine + "# Visual Studio {1}", formatVersion, yearTag);
  60         }
  61
  62         public void Add (MsbuildGenerator.VsCsproj vsproj)
  63         {
  64                 try {
  65                         libraries.Add (vsproj);
  66                 } catch (Exception ex) {
  67                         Console.WriteLine (ex);
  68                 }
  69         }
  70
  71         public void Write (string filename)
  72         {
  73                 var fullPath = Path.GetDirectoryName (filename) + "/";
  74
  75                 using (var sln = new StreamWriter (filename)) {
  76                         sln.WriteLine ();
  77                         sln.WriteLine (header);
  78                         foreach (var proj in libraries) {
  79                                 var unixProjFile = proj.csProjFilename.Replace ("\\", "/");
  80                                 var fullProjPath = Path.GetFullPath (unixProjFile);
  81                                 sln.WriteLine (project_start, proj.library, MsbuildGenerator.GetRelativePath (fullPath, fullProjPath), proj.projectGuid);
  82                                 sln.WriteLine (project_end);
  83                         }
  84                         sln.WriteLine ("Global");
  85
  86                         sln.WriteLine ("\tGlobalSection(SolutionConfigurationPlatforms) = preSolution");
  87                         sln.WriteLine ("\t\tDebug|Any CPU = Debug|Any CPU");
  88                         sln.WriteLine ("\t\tRelease|Any CPU = Release|Any CPU");
  89                         sln.WriteLine ("\tEndGlobalSection");
  90
  91                         sln.WriteLine ("\tGlobalSection(ProjectConfigurationPlatforms) = postSolution");
  92                         foreach (var proj in libraries) {
  93                                 var guid = proj.projectGuid;
  94                                 sln.WriteLine ("\t\t{0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU", guid);
  95                                 sln.WriteLine ("\t\t{0}.Debug|Any CPU.Build.0 = Debug|Any CPU", guid);
  96                                 sln.WriteLine ("\t\t{0}.Release|Any CPU.ActiveCfg = Release|Any CPU", guid);
  97                                 sln.WriteLine ("\t\t{0}.Release|Any CPU.Build.0 = Release|Any CPU", guid);
  98                         }
  99                         sln.WriteLine ("\tEndGlobalSection");
 100
 101                         sln.WriteLine ("\tGlobalSection(SolutionProperties) = preSolution");
 102                         sln.WriteLine ("\t\tHideSolutionNode = FALSE");
 103                         sln.WriteLine ("\tEndGlobalSection");
 104
 105                         sln.WriteLine ("EndGlobal");
 106                 }
 107         }
 108
 109         internal bool ContainsProjectIdentifier (string projId)
 110         {
 111                 return libraries.FindIndex (x => (x.library == projId)) >= 0;
 112         }
 113
 114         public int Count { get { return libraries.Count; } }
 115 }
 116
 117 class MsbuildGenerator {
 118         static readonly string NewLine = SlnGenerator.NewLine;
 119         static XmlNamespaceManager xmlns;
 120
 121         public const string profile_2_0 = "_2_0";
 122         public const string profile_3_5 = "_3_5";
 123         public const string profile_4_0 = "_4_0";
 124         public const string profile_4_x = "_4_x";
 125
 126         static void Usage ()
 127         {
 128                 Console.WriteLine ("Invalid argument");
 129         }
 130
 131         static string template;
 132         static MsbuildGenerator ()
 133         {
 134                 using (var input = new StreamReader ("csproj.tmpl")) {
 135                         template = input.ReadToEnd ();
 136                 }
 137
 138                 xmlns = new XmlNamespaceManager (new NameTable ());
 139                 xmlns.AddNamespace ("x", "http://schemas.microsoft.com/developer/msbuild/2003");
 140         }
 141
 142         // The directory as specified in order.xml
 143         public string dir;
 144         string library;
 145         string projectGuid;
 146         string fx_version;
 147
 148         XElement xproject;
 149         public string CsprojFilename;
 150
 151         //
 152         // Our base directory, this is relative to our exectution point mono/msvc/scripts
 153         string base_dir;
 154         string mcs_topdir;
 155
 156         public string LibraryOutput, AbsoluteLibraryOutput;
 157
 158         public MsbuildGenerator (XElement xproject)
 159         {
 160                 this.xproject = xproject;
 161                 dir = xproject.Attribute ("dir").Value;
 162                 library = xproject.Attribute ("library").Value;
 163                 CsprojFilename = "..\\..\\mcs\\" + dir + "\\" + library + ".csproj";
 164                 LibraryOutput = xproject.Element ("library_output").Value;
 165
 166                 projectGuid = LookupOrGenerateGuid ();
 167                 fx_version = xproject.Element ("fx_version").Value;
 168                 Csproj = new VsCsproj () {
 169                         csProjFilename = this.CsprojFilename,
 170                         projectGuid = this.projectGuid,
 171                         library_output = this.LibraryOutput,
 172                         fx_version = double.Parse (fx_version),
 173                         library = this.library,
 174                         MsbuildGenerator = this
 175                 };
 176
 177                 if (dir == "mcs") {
 178                         mcs_topdir = "../";
 179                         class_dir = "../class/";
 180                         base_dir = "../../mcs/mcs";
 181                 } else {
 182                         mcs_topdir = "../";
 183
 184                         foreach (char c in dir) {
 185                                 if (c == '/')
 186                                         mcs_topdir = "..//" + mcs_topdir;
 187                         }
 188                         class_dir = mcs_topdir.Substring (3);
 189
 190                         base_dir = Path.Combine ("..", "..", "mcs", dir);
 191                 }
 192                 AbsoluteLibraryOutput = Path.GetFullPath (Path.Combine (base_dir, LibraryOutput));
 193         }
 194
 195         string LookupOrGenerateGuid ()
 196         {
 197                 var projectFile = NativeName (CsprojFilename);
 198                 if (File.Exists (projectFile)){
 199                         var doc = XDocument.Load (projectFile);
 200                         return doc.XPathSelectElement ("x:Project/x:PropertyGroup/x:ProjectGuid", xmlns).Value;
 201                 }
 202                 return "{" + Guid.NewGuid ().ToString ().ToUpper () + "}";
 203         }
 204
 205         // Currently used
 206         bool Unsafe = false;
 207         StringBuilder defines = new StringBuilder ();
 208         bool Optimize = true;
 209         bool want_debugging_support = false;
 210         string main = null;
 211         Dictionary<string, string> embedded_resources = new Dictionary<string, string> ();
 212         List<string> warning_as_error = new List<string> ();
 213         List<int> ignore_warning = new List<int> ();
 214         bool load_default_config = true;
 215         bool StdLib = true;
 216         List<string> references = new List<string> ();
 217         List<string> libs = new List<string> ();
 218         List<string> reference_aliases = new List<string> ();
 219         bool showWarnings = true;
 220
 221         // Currently unused
 222 #pragma warning disable 0219, 0414
 223         int WarningLevel = 4;
 224
 225         bool Checked = false;
 226         bool WarningsAreErrors;
 227         bool VerifyClsCompliance = true;
 228         string win32IconFile;
 229         string StrongNameKeyFile;
 230         bool copyLocal = true;
 231         Target Target = Target.Library;
 232         string TargetExt = ".exe";
 233         string OutputFile;
 234         string StrongNameKeyContainer;
 235         bool StrongNameDelaySign = false;
 236         LanguageVersion Version = LanguageVersion.Default;
 237         string CodePage;
 238
 239         // Class directory, relative to
 240         string class_dir;
 241 #pragma warning restore 0219,414
 242
 243         readonly char [] argument_value_separator = new char [] { ';', ',' };
 244
 245         //
 246         // This parses the -arg and /arg options to the compiler, even if the strings
 247         // in the following text use "/arg" on the strings.
 248         //
 249         bool CSCParseOption (string option, ref string [] args)
 250         {
 251                 int idx = option.IndexOf (':');
 252                 string arg, value;
 253
 254                 if (idx == -1) {
 255                         arg = option;
 256                         value = "";
 257                 } else {
 258                         arg = option.Substring (0, idx);
 259
 260                         value = option.Substring (idx + 1);
 261                 }
 262
 263                 switch (arg.ToLower (CultureInfo.InvariantCulture)) {
 264                 case "/nologo":
 265                         return true;
 266
 267                 case "/t":
 268                 case "/target":
 269                         switch (value) {
 270                         case "exe":
 271                                 Target = Target.Exe;
 272                                 break;
 273
 274                         case "winexe":
 275                                 Target = Target.WinExe;
 276                                 break;
 277
 278                         case "library":
 279                                 Target = Target.Library;
 280                                 TargetExt = ".dll";
 281                                 break;
 282
 283                         case "module":
 284                                 Target = Target.Module;
 285                                 TargetExt = ".netmodule";
 286                                 break;
 287
 288                         default:
 289                                 return false;
 290                         }
 291                         return true;
 292
 293                 case "/out":
 294                         if (value.Length == 0) {
 295                                 Usage ();
 296                                 Environment.Exit (1);
 297                         }
 298                         OutputFile = value;
 299                         return true;
 300
 301                 case "/o":
 302                 case "/o+":
 303                 case "/optimize":
 304                 case "/optimize+":
 305                         Optimize = true;
 306                         return true;
 307
 308                 case "/o-":
 309                 case "/optimize-":
 310                         Optimize = false;
 311                         return true;
 312
 313                 case "/incremental":
 314                 case "/incremental+":
 315                 case "/incremental-":
 316                         // nothing.
 317                         return true;
 318
 319                 case "/d":
 320                 case "/define": {
 321                                 if (value.Length == 0) {
 322                                         Usage ();
 323                                         Environment.Exit (1);
 324                                 }
 325
 326                                 foreach (string d in value.Split (argument_value_separator)) {
 327                                         if (defines.Length != 0)
 328                                                 defines.Append (";");
 329                                         defines.Append (d);
 330                                 }
 331
 332                                 return true;
 333                         }
 334
 335                 case "/bugreport":
 336                         //
 337                         // We should collect data, runtime, etc and store in the file specified
 338                         //
 339                         return true;
 340                 case "/linkres":
 341                 case "/linkresource":
 342                 case "/res":
 343                 case "/resource":
 344                         bool embeded = arg [1] == 'r' || arg [1] == 'R';
 345                         string [] s = value.Split (argument_value_separator);
 346                         switch (s.Length) {
 347                         case 1:
 348                                 if (s [0].Length == 0)
 349                                         goto default;
 350                                 embedded_resources [s [0]] = Path.GetFileName (s [0]);
 351                                 break;
 352                         case 2:
 353                                 embedded_resources [s [0]] = s [1];
 354                                 break;
 355                         case 3:
 356                                 Console.WriteLine ("Does not support this method yet: {0}", arg);
 357                                 Environment.Exit (1);
 358                                 break;
 359                         default:
 360                                 Console.WriteLine ("Wrong number of arguments for option `{0}'", option);
 361                                 Environment.Exit (1);
 362                                 break;
 363                         }
 364
 365                         return true;
 366
 367                 case "/recurse":
 368                         Console.WriteLine ("/recurse not supported");
 369                         Environment.Exit (1);
 370                         return true;
 371
 372                 case "/r":
 373                 case "/reference": {
 374                                 if (value.Length == 0) {
 375                                         Console.WriteLine ("-reference requires an argument");
 376                                         Environment.Exit (1);
 377                                 }
 378
 379                                 string [] refs = value.Split (argument_value_separator);
 380                                 foreach (string r in refs) {
 381                                         string val = r;
 382                                         int index = val.IndexOf ('=');
 383                                         if (index > -1) {
 384                                                 reference_aliases.Add (r);
 385                                                 continue;
 386                                         }
 387
 388                                         if (val.Length != 0)
 389                                                 references.Add (val);
 390                                 }
 391                                 return true;
 392                         }
 393                 case "/main":
 394                         main = value;
 395                         return true;
 396
 397                 case "/m":
 398                 case "/addmodule":
 399                 case "/win32res":
 400                 case "/doc":
 401                         if (showWarnings)
 402                                 Console.WriteLine ("{0} = not supported", arg);
 403                         return true;
 404
 405                 case "/lib": {
 406                                 libs.Add (value);
 407                                 return true;
 408                         }
 409                 case "/win32icon": {
 410                                 win32IconFile = value;
 411                                 return true;
 412                         }
 413                 case "/debug-":
 414                         want_debugging_support = false;
 415                         return true;
 416
 417                 case "/debug":
 418                 case "/debug+":
 419                         want_debugging_support = true;
 420                         return true;
 421
 422                 case "/checked":
 423                 case "/checked+":
 424                         Checked = true;
 425                         return true;
 426
 427                 case "/checked-":
 428                         Checked = false;
 429                         return true;
 430
 431                 case "/clscheck":
 432                 case "/clscheck+":
 433                         return true;
 434
 435                 case "/clscheck-":
 436                         VerifyClsCompliance = false;
 437                         return true;
 438
 439                 case "/unsafe":
 440                 case "/unsafe+":
 441                         Unsafe = true;
 442                         return true;
 443
 444                 case "/unsafe-":
 445                         Unsafe = false;
 446                         return true;
 447
 448                 case "/warnaserror":
 449                 case "/warnaserror+":
 450                         if (value.Length == 0) {
 451                                 WarningsAreErrors = true;
 452                         } else {
 453                                 foreach (string wid in value.Split (argument_value_separator))
 454                                         warning_as_error.Add (wid);
 455                         }
 456                         return true;
 457
 458                 case "/-runtime":
 459                         // Console.WriteLine ("Warning ignoring /runtime:v4");
 460                         return true;
 461
 462                 case "/warnaserror-":
 463                         if (value.Length == 0) {
 464                                 WarningsAreErrors = false;
 465                         } else {
 466                                 foreach (string wid in value.Split (argument_value_separator))
 467                                         warning_as_error.Remove (wid);
 468                         }
 469                         return true;
 470
 471                 case "/warn":
 472                         WarningLevel = Int32.Parse (value);
 473                         return true;
 474
 475                 case "/nowarn": {
 476                                 string [] warns;
 477
 478                                 if (value.Length == 0) {
 479                                         Console.WriteLine ("/nowarn requires an argument");
 480                                         Environment.Exit (1);
 481                                 }
 482
 483                                 warns = value.Split (argument_value_separator);
 484                                 foreach (string wc in warns) {
 485                                         try {
 486                                                 if (wc.Trim ().Length == 0)
 487                                                         continue;
 488
 489                                                 int warn = Int32.Parse (wc);
 490                                                 if (warn < 1) {
 491                                                         throw new ArgumentOutOfRangeException ("warn");
 492                                                 }
 493                                                 ignore_warning.Add (warn);
 494                                         } catch {
 495                                                 Console.WriteLine (String.Format ("`{0}' is not a valid warning number", wc));
 496                                                 Environment.Exit (1);
 497                                         }
 498                                 }
 499                                 return true;
 500                         }
 501
 502                 case "/noconfig":
 503                         load_default_config = false;
 504                         return true;
 505
 506                 case "/nostdlib":
 507                 case "/nostdlib+":
 508                         StdLib = false;
 509                         return true;
 510
 511                 case "/nostdlib-":
 512                         StdLib = true;
 513                         return true;
 514
 515                 case "/fullpaths":
 516                         return true;
 517
 518                 case "/keyfile":
 519                         if (value == String.Empty) {
 520                                 Console.WriteLine ("{0} requires an argument", arg);
 521                                 Environment.Exit (1);
 522                         }
 523                         StrongNameKeyFile = value;
 524                         return true;
 525                 case "/keycontainer":
 526                         if (value == String.Empty) {
 527                                 Console.WriteLine ("{0} requires an argument", arg);
 528                                 Environment.Exit (1);
 529                         }
 530                         StrongNameKeyContainer = value;
 531                         return true;
 532                 case "/delaysign+":
 533                 case "/delaysign":
 534                         StrongNameDelaySign = true;
 535                         return true;
 536                 case "/delaysign-":
 537                         StrongNameDelaySign = false;
 538                         return true;
 539
 540                 case "/langversion":
 541                         switch (value.ToLower (CultureInfo.InvariantCulture)) {
 542                         case "iso-1":
 543                                 Version = LanguageVersion.ISO_1;
 544                                 return true;
 545
 546                         case "default":
 547                                 Version = LanguageVersion.Default;
 548                                 return true;
 549                         case "iso-2":
 550                                 Version = LanguageVersion.ISO_2;
 551                                 return true;
 552                         case "future":
 553                                 Version = LanguageVersion.Future;
 554                                 return true;
 555                         }
 556                         Console.WriteLine ("Invalid option `{0}' for /langversion. It must be either `ISO-1', `ISO-2' or `Default'", value);
 557                         Environment.Exit (1);
 558                         return true;
 559
 560                 case "/codepage":
 561                         CodePage = value;
 562                         return true;
 563
 564                 case "/publicsign":
 565                         return true;
 566
 567                 case "/-getresourcestrings":
 568                         return true;
 569                 }
 570
 571                 Console.WriteLine ("Failing with : {0}", arg);
 572                 return false;
 573         }
 574
 575         static string [] LoadArgs (string file)
 576         {
 577                 StreamReader f;
 578                 var args = new List<string> ();
 579                 string line;
 580                 try {
 581                         f = new StreamReader (file);
 582                 } catch {
 583                         return null;
 584                 }
 585
 586                 StringBuilder sb = new StringBuilder ();
 587
 588                 while ((line = f.ReadLine ()) != null) {
 589                         int t = line.Length;
 590
 591                         for (int i = 0; i < t; i++) {
 592                                 char c = line [i];
 593
 594                                 if (c == '"' || c == '\'') {
 595                                         char end = c;
 596
 597                                         for (i++; i < t; i++) {
 598                                                 c = line [i];
 599
 600                                                 if (c == end)
 601                                                         break;
 602                                                 sb.Append (c);
 603                                         }
 604                                 } else if (c == ' ') {
 605                                         if (sb.Length > 0) {
 606                                                 args.Add (sb.ToString ());
 607                                                 sb.Length = 0;
 608                                         }
 609                                 } else
 610                                         sb.Append (c);
 611                         }
 612                         if (sb.Length > 0) {
 613                                 args.Add (sb.ToString ());
 614                                 sb.Length = 0;
 615                         }
 616                 }
 617
 618                 string [] ret_value = new string [args.Count];
 619                 args.CopyTo (ret_value, 0);
 620
 621                 return ret_value;
 622         }
 623
 624         static string Load (string f)
 625         {
 626                 var native = NativeName (f);
 627
 628                 if (File.Exists (native)) {
 629                         using (var sr = new StreamReader (native)) {
 630                                 return sr.ReadToEnd ();
 631                         }
 632                 } else
 633                         return "";
 634         }
 635
 636         public static string NativeName (string path)
 637         {
 638                 if (System.IO.Path.DirectorySeparatorChar == '/')
 639                         return path.Replace ("\\", "/");
 640                 else
 641                         return path.Replace ("/", "\\");
 642         }
 643
 644         public class VsCsproj {
 645                 public string projectGuid;
 646                 public string output;
 647                 public string library_output;
 648                 public string csProjFilename;
 649                 public double fx_version;
 650                 public List<VsCsproj> projReferences = new List<VsCsproj> ();
 651                 public string library;
 652                 public MsbuildGenerator MsbuildGenerator;
 653         }
 654
 655         public VsCsproj Csproj;
 656
 657         public VsCsproj Generate (string library_output, Dictionary<string,MsbuildGenerator> projects, bool showWarnings = false)
 658         {
 659                 var generatedProjFile = NativeName (Csproj.csProjFilename);
 660                 //Console.WriteLine ("Generating: {0}", generatedProjFile);
 661
 662                 string boot, flags, output_name, built_sources, response, profile;
 663
 664                 boot = xproject.Element ("boot").Value;
 665                 flags = xproject.Element ("flags").Value;
 666                 output_name = xproject.Element ("output").Value;
 667                 if (output_name.EndsWith (".exe"))
 668                         Target = Target.Exe;
 669                 built_sources = xproject.Element ("built_sources").Value;
 670                 response = xproject.Element ("response").Value;
 671
 672                 profile = xproject.Element ("profile").Value;
 673                 if (string.IsNullOrEmpty (response)) {
 674                         // Address the issue where entries are missing the fx_version
 675                         // Should be fixed in the Makefile or elsewhere; this is a workaround
 676                         //<fx_version>basic</fx_version>
 677                         //<profile>./../build/deps/mcs.exe.sources.response</profile>
 678                         //<response></response>
 679                         response = profile;
 680                         profile = fx_version;
 681                         if (response.Contains ("build") || response.Contains ("basic") || response.Contains (profile_2_0)) {
 682                                 fx_version = "2.0";
 683                                 if (response.Contains (profile_2_0)) profile = "net_2_0";
 684                         } if (response.Contains ("build") || response.Contains ("basic") || response.Contains (profile_2_0)) {
 685                                 fx_version = "2.0";
 686                         } else if (response.Contains (profile_3_5)) {
 687                                 fx_version = "3.5";
 688                                 profile = "net_3_5";
 689                         } else if (response.Contains (profile_4_0)) {
 690                                 fx_version = "4.0";
 691                                 profile = "net_4_0";
 692                         } else if (response.Contains (profile_4_x)) {
 693                                 fx_version = "4.5";
 694                                 profile = "net_4_x";
 695                         }
 696                 }
 697                 //
 698                 // Prebuild code, might be in inputs, check:
 699                 //  inputs/LIBRARY.pre
 700                 //
 701                 string prebuild = GenerateStep (library, ".pre", "PreBuildEvent");
 702                 string postbuild = GenerateStep (library, ".post", "PostBuildEvent");
 703
 704                 var all_args = new Queue<string []> ();
 705                 all_args.Enqueue (flags.Split ());
 706                 while (all_args.Count > 0) {
 707                         string [] f = all_args.Dequeue ();
 708
 709                         for (int i = 0; i < f.Length; i++) {
 710                                 if (f [i].Length > 0 && f [i][0] == '-')
 711                                         f [i] = "/" + f [i].Substring (1);
 712
 713                                 if (f [i] [0] == '@') {
 714                                         string [] extra_args;
 715                                         string response_file = f [i].Substring (1);
 716
 717                                         var resp_file_full = Path.Combine (base_dir, response_file);
 718                                         extra_args = LoadArgs (resp_file_full);
 719                                         if (extra_args == null) {
 720                                                 Console.WriteLine ($"{library_output}: Unable to open response file: {resp_file_full}");
 721                                                 Environment.Exit (1);
 722                                         }
 723
 724                                         all_args.Enqueue (extra_args);
 725                                         continue;
 726                                 }
 727
 728                                 if (CSCParseOption (f [i], ref f))
 729                                         continue;
 730                                 Console.WriteLine ("{library_output}: Failure with {0}", f [i]);
 731                                 Environment.Exit (1);
 732                         }
 733                 }
 734
 735                 string [] source_files;
 736                 using (var reader = new StreamReader (NativeName (base_dir + "\\" + response))) {
 737                         source_files = reader.ReadToEnd ().Split ();
 738                 }
 739
 740                 Array.Sort (source_files);
 741
 742                 StringBuilder sources = new StringBuilder ();
 743                 foreach (string s in source_files) {
 744                         if (s.Length == 0)
 745                                 continue;
 746
 747                         string src = s.Replace ("/", "\\");
 748                         if (src.StartsWith (@"Test\..\"))
 749                                 src = src.Substring (8, src.Length - 8);
 750
 751                         sources.AppendFormat ("    <Compile Include=\"{0}\" />" + NewLine, src);
 752                 }
 753
 754                 source_files = built_sources.Split ();
 755                 Array.Sort (source_files);
 756
 757                 foreach (string s in source_files) {
 758                         if (s.Length == 0)
 759                                 continue;
 760
 761                         string src = s.Replace ("/", "\\");
 762                         if (src.StartsWith (@"Test\..\"))
 763                                 src = src.Substring (8, src.Length - 8);
 764
 765                         sources.AppendFormat ("    <Compile Include=\"{0}\" />" + NewLine, src);
 766                 }
 767                 sources.Remove (sources.Length - 1, 1);
 768
 769                 //if (library == "corlib-build") // otherwise, does not compile on fx_version == 4.0
 770                 //{
 771                 //    references.Add("System.dll");
 772                 //    references.Add("System.Xml.dll");
 773                 //}
 774
 775                 //if (library == "System.Core-build") // otherwise, slow compile. May be a transient need.
 776                 //{
 777                 //    this.ignore_warning.Add(1685);
 778                 //    this.ignore_warning.Add(0436);
 779                 //}
 780
 781                 var refs = new StringBuilder ();
 782
 783                 bool is_test = response.Contains ("_test_");
 784                 if (is_test) {
 785                         // F:\src\mono\mcs\class\lib\net_2_0\nunit.framework.dll
 786                         // F:\src\mono\mcs\class\SomeProject\SomeProject_test_-net_2_0.csproj
 787                         var nunitLibPath = string.Format (@"..\lib\{0}\nunit.framework.dll", profile);
 788                         refs.Append (string.Format ("    <Reference Include=\"{0}\" />" + NewLine, nunitLibPath));
 789                 }
 790
 791                 var resources = new StringBuilder ();
 792                 if (embedded_resources.Count > 0) {
 793                         resources.AppendFormat ("  <ItemGroup>" + NewLine);
 794                         foreach (var dk in embedded_resources) {
 795                                 var source = dk.Key;
 796                                 if (source.EndsWith (".resources"))
 797                                         source = source.Replace (".resources", ".resx");
 798                                 resources.AppendFormat ("    <EmbeddedResource Include=\"{0}\">" + NewLine, source);
 799                                 resources.AppendFormat ("      <LogicalName>{0}</LogicalName>" + NewLine, dk.Value);
 800                                 resources.AppendFormat ("    </EmbeddedResource>" + NewLine);
 801                         }
 802                         resources.AppendFormat ("  </ItemGroup>" + NewLine);
 803                 }
 804
 805
 806                 if (references.Count > 0 || reference_aliases.Count > 0) {
 807                         // -r:mscorlib.dll -r:System.dll
 808                         //<ProjectReference Include="..\corlib\corlib-basic.csproj">
 809                         //  <Project>{155aef28-c81f-405d-9072-9d52780e3e70}</Project>
 810                         //  <Name>corlib-basic</Name>
 811                         //</ProjectReference>
 812                         //<ProjectReference Include="..\System\System-basic.csproj">
 813                         //  <Project>{2094e859-db2f-481f-9630-f89d31d9ed48}</Project>
 814                         //  <Name>System-basic</Name>
 815                         //</ProjectReference>
 816                         var refdistinct = references.Distinct ();
 817                         foreach (string reference in refdistinct) {
 818
 819                                 var match = GetMatchingCsproj (library_output, reference, projects);
 820                                 if (match != null) {
 821                                         AddProjectReference (refs, Csproj, match, reference, null);
 822                                 } else {
 823                                         if (showWarnings){
 824                                                 Console.WriteLine ("{0}: Could not find a matching project reference for {1}", library, Path.GetFileName (reference));
 825                                                 Console.WriteLine ("  --> Adding reference with hintpath instead");
 826                                         }
 827                                         refs.Append ("    <Reference Include=\"" + reference + "\">" + NewLine);
 828                                         refs.Append ("      <SpecificVersion>False</SpecificVersion>" + NewLine);
 829                                         refs.Append ("      <HintPath>" + reference + "</HintPath>" + NewLine);
 830                                         refs.Append ("      <Private>False</Private>" + NewLine);
 831                                         refs.Append ("    </Reference>" + NewLine);
 832                                 }
 833                         }
 834
 835                         foreach (string r in reference_aliases) {
 836                                 int index = r.IndexOf ('=');
 837                                 string alias = r.Substring (0, index);
 838                                 string assembly = r.Substring (index + 1);
 839                                 var match = GetMatchingCsproj (library_output, assembly, projects, explicitPath: true);
 840                                 if (match != null) {
 841                                         AddProjectReference (refs, Csproj, match, r, alias);
 842                                 } else {
 843                                         throw new NotSupportedException (string.Format ("From {0}, could not find a matching project reference for {1}", library, r));
 844                                         refs.Append ("    <Reference Include=\"" + assembly + "\">" + NewLine);
 845                                         refs.Append ("      <SpecificVersion>False</SpecificVersion>" + NewLine);
 846                                         refs.Append ("      <HintPath>" + r + "</HintPath>" + NewLine);
 847                                         refs.Append ("      <Aliases>" + alias + "</Aliases>" + NewLine);
 848                                         refs.Append ("    </Reference>" + NewLine);
 849
 850                                 }
 851                         }
 852                 }
 853
 854                 // Possible inputs:
 855                 // ../class/lib/build/tmp/System.Xml.dll  [No longer possible, we should be removing this from order.xml]
 856                 //   /class/lib/basic/System.Core.dll
 857                 // <library_output>mcs.exe</library_output>
 858                 string build_output_dir;
 859                 if (LibraryOutput.Contains ("/"))
 860                         build_output_dir = Path.GetDirectoryName (LibraryOutput);
 861                 else
 862                         build_output_dir = "bin\\Debug\\" + library;
 863
 864                 bool basic_or_build = (library.Contains ("-basic") || library.Contains ("-build"));
 865
 866                 //
 867                 // Replace the template values
 868                 //
 869
 870                 string strongNameSection = "";
 871                 if (StrongNameKeyFile != null){
 872                         strongNameSection = String.Format (
 873                                 "  <PropertyGroup>" + NewLine +
 874                                 "    <SignAssembly>true</SignAssembly>" + NewLine +
 875                                 "{1}" +
 876                                 "  </PropertyGroup>" + NewLine +
 877                                 "  <PropertyGroup>" + NewLine +
 878                                 "    <AssemblyOriginatorKeyFile>{0}</AssemblyOriginatorKeyFile>" + NewLine +
 879                                 "  </PropertyGroup>", StrongNameKeyFile, StrongNameDelaySign ? "    <DelaySign>true</DelaySign>" + NewLine : "");
 880                 }
 881                 Csproj.output = template.
 882                         Replace ("@OUTPUTTYPE@", Target == Target.Library ? "Library" : "Exe").
 883                         Replace ("@SIGNATURE@", strongNameSection).
 884                         Replace ("@PROJECTGUID@", Csproj.projectGuid).
 885                         Replace ("@DEFINES@", defines.ToString ()).
 886                         Replace ("@DISABLEDWARNINGS@", string.Join (",", (from i in ignore_warning select i.ToString ()).ToArray ())).
 887                         //Replace("@NOSTDLIB@", (basic_or_build || (!StdLib)) ? "<NoStdLib>true</NoStdLib>" : string.Empty).
 888                         Replace ("@NOSTDLIB@", "<NoStdLib>" + (!StdLib).ToString () + "</NoStdLib>").
 889                         Replace ("@NOCONFIG@", "<NoConfig>" + (!load_default_config).ToString () + "</NoConfig>").
 890                         Replace ("@ALLOWUNSAFE@", Unsafe ? "<AllowUnsafeBlocks>true</AllowUnsafeBlocks>" : "").
 891                         Replace ("@FX_VERSION", fx_version).
 892                         Replace ("@ASSEMBLYNAME@", Path.GetFileNameWithoutExtension (output_name)).
 893                         Replace ("@OUTPUTDIR@", build_output_dir).
 894                         Replace ("@OUTPUTSUFFIX@", Path.GetFileName (build_output_dir)).
 895                         Replace ("@DEFINECONSTANTS@", defines.ToString ()).
 896                         Replace ("@DEBUG@", want_debugging_support ? "true" : "false").
 897                         Replace ("@DEBUGTYPE@", want_debugging_support ? "full" : "pdbonly").
 898                         Replace ("@REFERENCES@", refs.ToString ()).
 899                         Replace ("@PREBUILD@", prebuild).
 900                         Replace ("@POSTBUILD@", postbuild).
 901                         Replace ("@STARTUPOBJECT@", main == null ? "" : $"<StartupObject>{main}</StartupObject>").
 902                         //Replace ("@ADDITIONALLIBPATHS@", String.Format ("<AdditionalLibPaths>{0}</AdditionalLibPaths>", string.Join (",", libs.ToArray ()))).
 903                         Replace ("@ADDITIONALLIBPATHS@", String.Empty).
 904                         Replace ("@RESOURCES@", resources.ToString ()).
 905                         Replace ("@OPTIMIZE@", Optimize ? "true" : "false").
 906                         Replace ("@SOURCES@", sources.ToString ());
 907
 908                 //Console.WriteLine ("Generated {0}", ofile.Replace ("\\", "/"));
 909                 using (var o = new StreamWriter (generatedProjFile)) {
 910                         o.WriteLine (Csproj.output);
 911                 }
 912
 913                 return Csproj;
 914         }
 915
 916         string GenerateStep (string library, string suffix, string eventKey)
 917         {
 918                 string target = Load (library + suffix);
 919                 string target_windows, target_unix;
 920
 921                 int q = library.IndexOf ("-");
 922                 if (q != -1)
 923                         target = target + Load (library.Substring (0, q) + suffix);
 924
 925                 if (target.IndexOf ("@MONO@") != -1){
 926                         target_unix = target.Replace ("@MONO@", "mono").Replace ("@CAT@", "cat");
 927                         target_windows = target.Replace ("@MONO@", "").Replace ("@CAT@", "type");
 928                 } else {
 929                         target_unix = target.Replace ("jay.exe", "jay");
 930                         target_windows = target;
 931                 }
 932                 target_unix = target_unix.Replace ("@COPY@", "cp");
 933                 target_windows = target_unix.Replace ("@COPY@", "copy");
 934
 935                 target_unix = target_unix.Replace ("\r", "");
 936                 const string condition_unix    = "Condition=\" '$(OS)' != 'Windows_NT' \"";
 937                 const string condition_windows = "Condition=\" '$(OS)' == 'Windows_NT' \"";
 938                 var result =
 939                         $"    <{eventKey} {condition_unix}>\n{target_unix}\n    </{eventKey}>{NewLine}" +
 940                         $"    <{eventKey} {condition_windows}>{NewLine}{target_windows}{NewLine}    </{eventKey}>";
 941                 return result;
 942         }
 943
 944         void AddProjectReference (StringBuilder refs, VsCsproj result, MsbuildGenerator match, string r, string alias)
 945         {
 946                 refs.AppendFormat ("    <ProjectReference Include=\"{0}\">{1}", GetRelativePath (result.csProjFilename, match.CsprojFilename), NewLine);
 947                 refs.Append ("      <Project>" + match.projectGuid + "</Project>" + NewLine);
 948                 refs.Append ("      <Name>" + Path.GetFileNameWithoutExtension (match.CsprojFilename.Replace ('\\', Path.DirectorySeparatorChar)) + "</Name>" + NewLine);
 949                 if (alias != null)
 950                         refs.Append ("      <Aliases>" + alias + "</Aliases>");
 951                 refs.Append ("    </ProjectReference>" + NewLine);
 952                 if (!result.projReferences.Contains (match.Csproj))
 953                         result.projReferences.Add (match.Csproj);
 954         }
 955
 956         public static string GetRelativePath (string from, string to)
 957         {
 958                 from = from.Replace ("\\", "/");
 959                 to = to.Replace ("\\", "/");
 960                 var fromUri = new Uri (Path.GetFullPath (from));
 961                 var toUri = new Uri (Path.GetFullPath (to));
 962
 963                 var ret =  fromUri.MakeRelativeUri (toUri).ToString ().Replace ("%5C", "\x5c");
 964                 return ret;
 965         }
 966
 967         MsbuildGenerator GetMatchingCsproj (string library_output, string dllReferenceName, Dictionary<string,MsbuildGenerator> projects, bool explicitPath = false)
 968         {
 969                 // libDir would be "./../../class/lib/net_4_x for example
 970                 // project
 971                 if (!dllReferenceName.EndsWith (".dll") && !dllReferenceName.EndsWith (".exe"))
 972                         dllReferenceName += ".dll";
 973
 974                 var probe = Path.GetFullPath (Path.Combine (base_dir, dllReferenceName));
 975                 foreach (var project in projects){
 976                         if (probe == project.Value.AbsoluteLibraryOutput)
 977                                 return project.Value;
 978                 }
 979
 980                 // not explicit, search for the library in the lib path order specified
 981
 982                 foreach (var libDir in libs) {
 983                         var abs = Path.GetFullPath (Path.Combine (base_dir, libDir));
 984                         foreach (var project in projects){
 985                                 probe = Path.Combine (abs, dllReferenceName);
 986
 987                                 if (probe == project.Value.AbsoluteLibraryOutput)
 988                                         return project.Value;
 989                         }
 990                 }
 991
 992                 // Last attempt, try to find the library in all the projects
 993                 foreach (var project in projects) {
 994                         if (project.Value.AbsoluteLibraryOutput.EndsWith (dllReferenceName))
 995                                 return project.Value;
 996
 997                 }
 998                 var ljoined = String.Join (", ", libs);
 999                 Console.WriteLine ($"{library_output}: did not find referenced {dllReferenceName} with libs={ljoined}");
1000                 foreach (var p in projects) {
1001                         Console.WriteLine ("{0}", p.Value.AbsoluteLibraryOutput);
1002                 }
1003                 return null;
1004         }
1005
1006 }
1007
1008 public class Driver {
1009
1010         static IEnumerable<XElement> GetProjects (bool full = false)
1011         {
1012                 XDocument doc = XDocument.Load ("order.xml");
1013                 foreach (XElement project in doc.Root.Elements ()) {
1014                         string dir = project.Attribute ("dir").Value;
1015                         string library = project.Attribute ("library").Value;
1016                         var profile = project.Element ("profile").Value;
1017
1018 #if false
1019                         // Skip facades for now, the tool doesn't know how to deal with them yet.
1020                         if (dir.Contains ("Facades"))
1021                                 continue;
1022
1023                         // These are currently broken, skip until they're fixed.
1024                         if (dir.StartsWith ("mcs") || dir.Contains ("apigen"))
1025                                 continue;
1026
1027                         //
1028                         // Do only class libraries for now
1029                         //
1030                         if (!(dir.StartsWith ("class") || dir.StartsWith ("mcs") || dir.StartsWith ("basic")))
1031                                 continue;
1032
1033                         if (full){
1034                                 if (!library.Contains ("tests"))
1035                                         yield return project;
1036                                 continue;
1037                         }
1038 #endif
1039                         //
1040                         // Do not do 2.1, it is not working yet
1041                         // Do not do basic, as there is no point (requires a system mcs to be installed).
1042                         //
1043                         if (library.Contains ("moonlight") || library.Contains ("-basic") || library.EndsWith ("bootstrap")  || library.Contains ("build"))
1044                                 continue;
1045
1046                         // The next ones are to make debugging easier for now
1047                         if (profile == "basic")
1048                                 continue;
1049
1050                         // For now -- problem is, our resolver currently only considers the assembly name, and we ahve
1051                         // conflicing 2.0 and 2.4 versions so for now, we just skip the nunit20 versions
1052                         if (dir.Contains ("nunit20"))
1053                                 continue;
1054
1055 #if true
1056                         if (profile != "net_4_x" || library.Contains ("tests"))
1057                                 continue;
1058 #endif
1059                         //Console.WriteLine ("Going to handle {0}", library);
1060                         yield return project;
1061                 }
1062         }
1063
1064         static void Main (string [] args)
1065         {
1066                 if (!File.Exists ("genproj.cs")) {
1067                         Console.WriteLine ("This command must be executed from mono/msvc/scripts");
1068                         Environment.Exit (1);
1069                 }
1070
1071                 if (args.Length == 1 && args [0].ToLower ().Contains ("-h")) {
1072                         Console.WriteLine ("Usage:");
1073                         Console.WriteLine ("genproj.exe [visual_studio_release] [output_full_solutions]");
1074                         Console.WriteLine ("If output_full_solutions is false, only the main System*.dll");
1075                         Console.WriteLine (" assemblies (and dependencies) is included in the solution.");
1076                         Console.WriteLine ("Example:");
1077                         Console.WriteLine ("genproj.exe 2012 false");
1078                         Console.WriteLine ("genproj.exe with no arguments is equivalent to 'genproj.exe 2012 true'\n\n");
1079                         Console.WriteLine ("genproj.exe deps");
1080                         Console.WriteLine ("Generates a Makefile dependency file from the projects input");
1081                         Environment.Exit (0);
1082                 }
1083
1084                 var slnVersion = (args.Length > 0) ? args [0] : "2012";
1085                 bool fullSolutions = (args.Length > 1) ? bool.Parse (args [1]) : true;
1086
1087                 // To generate makefile depenedencies
1088                 var makefileDeps =  (args.Length > 0 && args [0] == "deps");
1089
1090                 var sln_gen = new SlnGenerator (slnVersion);
1091                 var four_five_sln_gen = new SlnGenerator (slnVersion);
1092                 var projects = new Dictionary<string,MsbuildGenerator> ();
1093
1094                 var duplicates = new List<string> ();
1095                 foreach (var project in GetProjects (makefileDeps)) {
1096                         var library_output = project.Element ("library_output").Value;
1097                         projects [library_output] = new MsbuildGenerator (project);
1098                 }
1099                 foreach (var project in GetProjects (makefileDeps)){
1100                         var library_output = project.Element ("library_output").Value;
1101                         //Console.WriteLine ("=== {0} ===", library_output);
1102                         var gen = projects [library_output];
1103                         try {
1104                                 var csproj = gen.Generate (library_output, projects);
1105                                 var csprojFilename = csproj.csProjFilename;
1106                                 if (!sln_gen.ContainsProjectIdentifier (csproj.library)) {
1107                                         sln_gen.Add (csproj);
1108                                 } else {
1109                                         duplicates.Add (csprojFilename);
1110                                 }
1111
1112                         } catch (Exception e) {
1113                                 Console.WriteLine ("Error in {0}\n{1}", project, e);
1114                         }
1115                 }
1116
1117                 Func<MsbuildGenerator.VsCsproj, bool> additionalFilter;
1118                 additionalFilter = fullSolutions ? (Func<MsbuildGenerator.VsCsproj, bool>)null : IsCommonLibrary;
1119
1120                 FillSolution (four_five_sln_gen, MsbuildGenerator.profile_4_x, projects.Values, additionalFilter);
1121
1122                 if (duplicates.Count () > 0) {
1123                         var sb = new StringBuilder ();
1124                         sb.AppendLine ("WARNING: Skipped some project references, apparent duplicates in order.xml:");
1125                         foreach (var item in duplicates) {
1126                                 sb.AppendLine (item);
1127                         }
1128                         Console.WriteLine (sb.ToString ());
1129                 }
1130
1131                 WriteSolution (four_five_sln_gen, Path.Combine ("..", "..", MakeSolutionName (MsbuildGenerator.profile_4_x)));
1132
1133                 if (makefileDeps){
1134                         const string classDirPrefix = "./../../";
1135                         Console.WriteLine ("here {0}", sln_gen.libraries.Count);
1136                         foreach (var p in sln_gen.libraries){
1137                                 string rebasedOutput = RebaseToClassDirectory (MsbuildGenerator.GetRelativePath ("../../mcs/class", p.library_output));
1138
1139                                 Console.Write ("{0}: ", rebasedOutput);
1140                                 foreach (var r in p.projReferences){
1141                                         var lo = r.library_output;
1142                                         if (lo.StartsWith (classDirPrefix))
1143                                                 lo = lo.Substring (classDirPrefix.Length);
1144                                         else
1145                                                 lo = "<<ERROR-dependency is not a class library>>";
1146                                         Console.Write ("{0} ", lo);
1147                                 }
1148                                 Console.Write ("\n\t(cd {0}; make {1})", p.MsbuildGenerator.dir, p.library_output);
1149                                 Console.WriteLine ("\n");
1150                         }
1151                 }
1152
1153                 // A few other optional solutions
1154                 // Solutions with 'everything' and the most common libraries used in development may be of interest
1155                 //WriteSolution (sln_gen, "./mcs_full.sln");
1156                 //WriteSolution (small_full_sln_gen, "small_full.sln");
1157                 // The following may be useful if lacking visual studio or MonoDevelop, to bootstrap mono compiler self-hosting
1158                 //WriteSolution (basic_sln_gen, "mcs_basic.sln");
1159                 //WriteSolution (build_sln_gen, "mcs_build.sln");
1160         }
1161
1162         // Rebases a path, assuming that execution is taking place in the "class" subdirectory,
1163         // so it strips ../class/ from a path, which is a no-op
1164         static string RebaseToClassDirectory (string path)
1165         {
1166                 const string prefix = "../class/";
1167                 int p = path.IndexOf (prefix);
1168                 if (p == -1)
1169                         return path;
1170                 return path.Substring (0, p) + path.Substring (p+prefix.Length);
1171                 return path;
1172         }
1173
1174         static string MakeSolutionName (string profileTag)
1175         {
1176                 return "net" + profileTag + ".sln";
1177         }
1178
1179         static void FillSolution (SlnGenerator solution, string profileString, IEnumerable<MsbuildGenerator> projects, Func<MsbuildGenerator.VsCsproj, bool> additionalFilter = null)
1180         {
1181                 foreach (var generator in projects) {
1182                         var vsCsproj = generator.Csproj;
1183                         if (!vsCsproj.library.Contains (profileString))
1184                                 continue;
1185                         if (additionalFilter != null && !additionalFilter (vsCsproj))
1186                                 continue;
1187                         var csprojFilename = vsCsproj.csProjFilename;
1188                         if (!solution.ContainsProjectIdentifier (vsCsproj.library)) {
1189                                 solution.Add (vsCsproj);
1190                                 RecursiveAddProj (solution, vsCsproj);
1191                         }
1192                 }
1193         }
1194
1195         static void RecursiveAddProj (SlnGenerator solution, MsbuildGenerator.VsCsproj vsCsproj, int recursiveDepth = 1)
1196         {
1197                 const int max_recursive = 16;
1198                 if (recursiveDepth > max_recursive) throw new Exception (string.Format ("Reached {0} levels of project dependency", max_recursive));
1199                 foreach (var projRef in vsCsproj.projReferences) {
1200                         if (!solution.ContainsProjectIdentifier (projRef.library)) {
1201                                 solution.Add (projRef);
1202                                 RecursiveAddProj (solution, projRef, recursiveDepth + 1);
1203                         }
1204                 }
1205         }
1206
1207         static void WriteSolution (SlnGenerator sln_gen, string slnfilename)
1208         {
1209                 Console.WriteLine (String.Format ("Writing solution {1}, with {0} projects", sln_gen.Count, slnfilename));
1210                 sln_gen.Write (slnfilename);
1211         }
1212
1213         static bool IsCommonLibrary (MsbuildGenerator.VsCsproj proj)
1214         {
1215                 var library = proj.library;
1216                 //if (library.Contains ("-basic"))
1217                 //      return true;
1218                 //if (library.Contains ("-build"))
1219                 //      return true;
1220                 //if (library.StartsWith ("corlib"))
1221                 //      return true;
1222                 if (library.StartsWith ("System-"))
1223                         return true;
1224                 if (library.StartsWith ("System.Xml"))
1225                         return true;
1226                 if (library.StartsWith ("System.Secu"))
1227                         return true;
1228                 if (library.StartsWith ("System.Configuration"))
1229                         return true;
1230                 if (library.StartsWith ("System.Core"))
1231                         return true;
1232                 //if (library.StartsWith ("Mono."))
1233                 //      return true;
1234
1235                 return false;
1236         }
1237 }