From a6dfc69c0cf3b492daddcca79bd21489d5ea36ec Mon Sep 17 00:00:00 2001 From: Matt Ward Date: Wed, 12 Oct 2005 21:56:07 +0000 Subject: [PATCH] Added support for Mono 1.1.9.2 git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@568 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61 --- .../ICSharpCode.Build.Tasks.sln | 8 + .../Project/CompilerCommandLineArguments.cs | 127 ++++++ .../Project/CompilerResultsParser.cs | 76 ++++ .../ICSharpCode.Build.Tasks/Project/Gmcs.cs | 29 ++ .../Project/ICSharpCode.Build.Tasks.csproj | 15 +- .../Project/ICompilerResultsParser.cs | 17 + .../ICSharpCode.Build.Tasks/Project/Mcs.cs | 29 ++ .../Project/MonoCompiler.cs | 53 +++ .../Project/MonoCompilerTask.cs | 370 ++++++++++++++++++ .../Project/SharpDevelop.Build.CSharp.targets | 14 +- .../SharpDevelop.Build.Mono.Gmcs.targets | 63 +++ .../SharpDevelop.Build.Mono.Mcs.targets | 63 +++ .../Test/AssemblyInfo.cs | 27 ++ .../Test/CompilerCommandLineTestFixture.cs | 273 +++++++++++++ .../Test/GeneralErrorParseTestFixture.cs | 47 +++ .../Test/ICSharpCode.Build.Tasks.Tests.csproj | 56 +++ .../Test/NormalMonoErrorParseTestFixture.cs | 65 +++ .../ProjectOptions/AbstractBuildOptions.cs | 4 +- .../Resources/BitmapResources.resources | Bin 514425 -> 515906 bytes .../Resources/StringResources.resources | Bin 242335 -> 242219 bytes src/SharpDevelop.WithTests.sln | 3 + 21 files changed, 1335 insertions(+), 4 deletions(-) create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/ICSharpCode.Build.Tasks.sln create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Project/CompilerCommandLineArguments.cs create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Project/CompilerResultsParser.cs create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Project/Gmcs.cs create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Project/ICompilerResultsParser.cs create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Project/Mcs.cs create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Project/MonoCompiler.cs create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Project/MonoCompilerTask.cs create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.Mono.Gmcs.targets create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.Mono.Mcs.targets create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Test/AssemblyInfo.cs create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Test/CompilerCommandLineTestFixture.cs create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Test/GeneralErrorParseTestFixture.cs create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Test/ICSharpCode.Build.Tasks.Tests.csproj create mode 100644 src/Libraries/ICSharpCode.Build.Tasks/Test/NormalMonoErrorParseTestFixture.cs diff --git a/src/Libraries/ICSharpCode.Build.Tasks/ICSharpCode.Build.Tasks.sln b/src/Libraries/ICSharpCode.Build.Tasks/ICSharpCode.Build.Tasks.sln new file mode 100644 index 0000000000..26da2d8060 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/ICSharpCode.Build.Tasks.sln @@ -0,0 +1,8 @@ +Microsoft Visual Studio Solution File, Format Version 9.00 +# SharpDevelop 2.0.0.546 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Build.Tasks", "Project\ICSharpCode.Build.Tasks.csproj", "{4139CCF6-FB49-4A9D-B2CF-331E9EA3198D}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Build.Tasks.Tests", "Test\ICSharpCode.Build.Tasks.Tests.csproj", "{B7C2A664-B454-4920-AC6E-318F5274B2EF}" +EndProject +Global +EndGlobal diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Project/CompilerCommandLineArguments.cs b/src/Libraries/ICSharpCode.Build.Tasks/Project/CompilerCommandLineArguments.cs new file mode 100644 index 0000000000..a0b8e99cf0 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Project/CompilerCommandLineArguments.cs @@ -0,0 +1,127 @@ +// +// 2002-2005 AlphaSierraPapa +// GNU General Public License +// +// $Revision$ +// + +using Microsoft.Build.Framework; +using Microsoft.Build.Tasks; +using Microsoft.Build.Utilities; +using System; +using System.Text; +using System.IO; + +namespace ICSharpCode.Build.Tasks +{ + public class CompilerCommandLineArguments : CommandLineBuilderExtension + { + public CompilerCommandLineArguments(MonoCompilerTask compilerTask) + { + GenerateCommandLineArguments(compilerTask); + } + + public static bool IsNetModule(string fileName) + { + return Path.GetExtension(fileName).ToLowerInvariant() == ".netmodule"; + } + + void GenerateCommandLineArguments(MonoCompilerTask compilerTask) + { + AppendSwitchIfTrue("-noconfig", compilerTask.NoConfig); + AppendSwitch("-warn:", compilerTask.WarningLevel.ToString()); + AppendFileNameIfNotNull("-out:", compilerTask.OutputAssembly); + AppendTarget(compilerTask.TargetType); + AppendSwitchWithoutParameterIfNotNull("-debug", compilerTask.DebugType); + AppendSwitchIfTrue("-optimize", compilerTask.Optimize); + AppendSwitchIfTrue("-nologo", compilerTask.NoLogo); + AppendSwitchIfTrue("-unsafe", compilerTask.AllowUnsafeBlocks); + AppendSwitchIfTrue("-nostdlib", compilerTask.NoStandardLib); + AppendSwitchIfTrue("-checked", compilerTask.CheckForOverflowUnderflow); + AppendSwitchIfTrue("-delaysign", compilerTask.DelaySign); + AppendSwitchIfNotNull("-langversion:", compilerTask.LangVersion); + AppendSwitchIfNotNull("-keycontainer:", compilerTask.KeyContainer); + AppendSwitchIfNotNull("-keyfile:", compilerTask.KeyFile); + AppendSwitchIfNotNull("-define:", compilerTask.DefineConstants); + AppendSwitchIfTrue("-warnaserror", compilerTask.TreatWarningsAsErrors); + AppendSwitchIfNotNull("-nowarn:", compilerTask.DisabledWarnings); + AppendSwitchIfNotNull("-main:", compilerTask.MainEntryPoint); + AppendFileNameIfNotNull("-doc:", compilerTask.DocumentationFile); + AppendSwitchIfNotNull("-lib:", compilerTask.AdditionalLibPaths, ","); + AppendReferencesIfNotNull(compilerTask.References); + AppendResourcesIfNotNull(compilerTask.Resources); + AppendFileNameIfNotNull("-win32res:", compilerTask.Win32Resource); + AppendFileNameIfNotNull("-win32icon:", compilerTask.Win32Icon); + AppendFileNamesIfNotNull(compilerTask.Sources, " "); + } + + void AppendReferencesIfNotNull(ITaskItem[] references) + { + if (references == null) { + return; + } + + foreach (ITaskItem reference in references) { + string fileName = reference.ItemSpec; + if (CompilerCommandLineArguments.IsNetModule(fileName)) { + AppendFileNameIfNotNull("-addmodule:", reference); + } else { + AppendFileNameIfNotNull("-r:", reference); + } + } + } + + void AppendResourcesIfNotNull(ITaskItem[] resources) + { + if (resources == null) { + return; + } + + foreach (ITaskItem resource in resources) { + AppendFileNameIfNotNull("-resource:", resource); + } + } + + void AppendSwitchWithoutParameterIfNotNull(string switchName, string parameter) + { + if (parameter != null && parameter.Trim().Length > 0) { + AppendSwitch(switchName); + } + } + + void AppendSwitchIfTrue(string switchName, bool parameter) + { + if (parameter) { + AppendSwitch(switchName); + } + } + + void AppendSwitch(string switchName, string parameter) + { + AppendSwitchIfNotNull(switchName, parameter); + } + + void AppendFileNameIfNotNull(string switchName, ITaskItem fileItem) + { + if (fileItem != null) { + AppendFileNameIfNotNull(switchName, fileItem.ItemSpec); + } + } + + void AppendFileNameIfNotNull(string switchName, string fileName) + { + if (fileName != null) { + AppendSpaceIfNotEmpty(); + AppendTextUnquoted(switchName); + AppendFileNameWithQuoting(fileName); + } + } + + void AppendTarget(string targetType) + { + if (targetType != null) { + AppendSwitch("-target:", targetType.ToLowerInvariant()); + } + } + } +} diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Project/CompilerResultsParser.cs b/src/Libraries/ICSharpCode.Build.Tasks/Project/CompilerResultsParser.cs new file mode 100644 index 0000000000..655e8b0359 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Project/CompilerResultsParser.cs @@ -0,0 +1,76 @@ +// +// 2002-2005 AlphaSierraPapa +// GNU General Public License +// +// $Revision$ +// + +using System; +using System.CodeDom.Compiler; +using System.IO; +using System.Text; +using System.Text.RegularExpressions; + +namespace ICSharpCode.Build.Tasks +{ + public class CompilerResultsParser : ICompilerResultsParser + { + public const string NormalErrorPattern = @"(?.*)\((?\d+),(?\d+)\):\s+(?\w+)\s+(?[\d\w]+):\s+(?.*)"; + public const string GeneralErrorPattern = @"(?.+?)\s+(?[\d\w]+?):\s+(?.*)"; + + Regex normalError = new Regex(NormalErrorPattern, RegexOptions.Compiled); + Regex generalError = new Regex(GeneralErrorPattern, RegexOptions.Compiled); + + public CompilerResultsParser() + { + } + + public CompilerResults Parse(TempFileCollection tempFiles, string fileName) + { + CompilerResults results = new CompilerResults(tempFiles); + + StringBuilder compilerOutput = new StringBuilder(); + StreamReader resultsReader = File.OpenText(fileName); + + while (true) { + string curLine = resultsReader.ReadLine(); + compilerOutput.Append(curLine); + compilerOutput.Append('\n'); + if (curLine == null) { + break; + } + curLine = curLine.Trim(); + if (curLine.Length == 0) { + continue; + } + + CompilerError error = new CompilerError(); + + // try to match standard mono errors + Match match = normalError.Match(curLine); + if (match.Success) { + error.Column = Int32.Parse(match.Result("${column}")); + error.Line = Int32.Parse(match.Result("${line}")); + error.FileName = Path.GetFullPath(match.Result("${file}")); + error.IsWarning = match.Result("${error}") == "warning"; + error.ErrorNumber = match.Result("${number}"); + error.ErrorText = match.Result("${message}"); + + results.Errors.Add(error); + } else { + match = generalError.Match(curLine); + if (match.Success) { + error.IsWarning = match.Result("${error}") == "warning"; + error.ErrorNumber = match.Result("${number}"); + error.ErrorText = match.Result("${message}"); + + results.Errors.Add(error); + } + } + } + resultsReader.Close(); + + return results; + } + } +} diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Project/Gmcs.cs b/src/Libraries/ICSharpCode.Build.Tasks/Project/Gmcs.cs new file mode 100644 index 0000000000..ddb8a37d8c --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Project/Gmcs.cs @@ -0,0 +1,29 @@ +// +// 2002-2005 AlphaSierraPapa +// GNU General Public License +// +// $Revision$ +// + +using Microsoft.Build.Framework; +using System; + +namespace ICSharpCode.Build.Tasks +{ + /// + /// MSBuild task for Mono's GMCS. + /// + public class Gmcs : MonoCompilerTask + { + protected override string ToolName { + get { + return "Gmcs.exe"; + } + } + + protected override string GenerateFullPathToTool() + { + return String.Concat(Environment.GetEnvironmentVariable("ComSpec"), " /c gmcs"); + } + } +} diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Project/ICSharpCode.Build.Tasks.csproj b/src/Libraries/ICSharpCode.Build.Tasks/Project/ICSharpCode.Build.Tasks.csproj index 1f78783456..707cd8bf8f 100644 --- a/src/Libraries/ICSharpCode.Build.Tasks/Project/ICSharpCode.Build.Tasks.csproj +++ b/src/Libraries/ICSharpCode.Build.Tasks/Project/ICSharpCode.Build.Tasks.csproj @@ -34,6 +34,19 @@ + + Always + + + + + + + + + + Always + @@ -41,4 +54,4 @@ - + \ No newline at end of file diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Project/ICompilerResultsParser.cs b/src/Libraries/ICSharpCode.Build.Tasks/Project/ICompilerResultsParser.cs new file mode 100644 index 0000000000..1190ad23ae --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Project/ICompilerResultsParser.cs @@ -0,0 +1,17 @@ +// +// 2002-2005 AlphaSierraPapa +// GNU General Public License +// +// $Revision$ +// + +using System; +using System.CodeDom.Compiler; + +namespace ICSharpCode.Build.Tasks +{ + public interface ICompilerResultsParser + { + CompilerResults Parse(TempFileCollection tempFiles, string fileName); + } +} diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Project/Mcs.cs b/src/Libraries/ICSharpCode.Build.Tasks/Project/Mcs.cs new file mode 100644 index 0000000000..e475826868 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Project/Mcs.cs @@ -0,0 +1,29 @@ +// +// 2002-2005 AlphaSierraPapa +// GNU General Public License +// +// $Revision$ +// + +using Microsoft.Build.Framework; +using System; + +namespace ICSharpCode.Build.Tasks +{ + /// + /// MSBuild task for Mono's MCS. + /// + public class Mcs : MonoCompilerTask + { + protected override string ToolName { + get { + return "Mcs.exe"; + } + } + + protected override string GenerateFullPathToTool() + { + return String.Concat(Environment.GetEnvironmentVariable("ComSpec"), " /c mcs"); + } + } +} diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Project/MonoCompiler.cs b/src/Libraries/ICSharpCode.Build.Tasks/Project/MonoCompiler.cs new file mode 100644 index 0000000000..42586694a9 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Project/MonoCompiler.cs @@ -0,0 +1,53 @@ +// +// 2002-2005 AlphaSierraPapa +// GNU General Public License +// +// $Revision$ +// + +using System; +using System.CodeDom.Compiler; +using System.IO; + +namespace ICSharpCode.Build.Tasks +{ + public class MonoCompiler + { + CompilerResults results; + + public MonoCompiler() + { + } + + public int Run(string compiler, string args, ICompilerResultsParser parser) + { + string responseFileName = Path.GetTempFileName(); + + using (StreamWriter writer = new StreamWriter(responseFileName)) { + writer.Write(args); + } + + //string outstr = String.Concat(compilerFileName, compilerparameters.NoConfig ? " /noconfig" : String.Empty, " \"@", responseFileName, "\""); + string outputFileName = String.Empty; + string errorFileName = String.Empty; + TempFileCollection tempFiles = new TempFileCollection(); + string command = String.Concat(compiler, " \"@", responseFileName, "\""); + + int returnValue = Executor.ExecWaitWithCapture(command, tempFiles, ref outputFileName, ref errorFileName); + + results = parser.Parse(tempFiles, errorFileName); + + File.Delete(responseFileName); + File.Delete(outputFileName); + File.Delete(errorFileName); + + return returnValue; + } + + public CompilerResults Results { + get { + return results; + } + } + } +} diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Project/MonoCompilerTask.cs b/src/Libraries/ICSharpCode.Build.Tasks/Project/MonoCompilerTask.cs new file mode 100644 index 0000000000..fbb30d8cc8 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Project/MonoCompilerTask.cs @@ -0,0 +1,370 @@ +// +// 2002-2005 AlphaSierraPapa +// GNU General Public License +// +// $Revision$ +// + +using Microsoft.Build.Framework; +using Microsoft.Build.Utilities; +using System; +using System.CodeDom.Compiler; + +namespace ICSharpCode.Build.Tasks +{ + /// + /// Base class task for the mono compilers mcs and gmcs. + /// + public abstract class MonoCompilerTask : MyToolTask + { + string[] additionalLibPaths; + string[] addModules; + bool allowUnsafeBlocks; + bool checkForOverflowUnderflow; + int codePage; + string debugType; + string defineConstants; + bool delaySign; + string disabledWarnings; + string documentationFile; + string emitDebugInformation; + string keyContainer; + string keyFile; + string langVersion; + ITaskItem[] linkResources; + string mainEntryPoint; + string moduleAssemblyName; + bool noConfig; + bool noLogo; + bool noStandardLib; + bool optimize; + ITaskItem outputAssembly; + ITaskItem[] references; + ITaskItem[] resources; + ITaskItem[] responseFiles; + ITaskItem[] sources; + string targetType; + bool treatWarningsAsErrors; + int warningLevel; + string win32Icon; + string win32Resource; + + public string[] AdditionalLibPaths { + get { + return additionalLibPaths; + } + set { + additionalLibPaths = value; + } + } + + public string[] AddModules { + get { + return addModules; + } + set { + addModules = value; + } + } + + public bool AllowUnsafeBlocks { + get { + return allowUnsafeBlocks; + } + set { + allowUnsafeBlocks = value; + } + } + + public bool CheckForOverflowUnderflow { + get { + return checkForOverflowUnderflow; + } + set { + checkForOverflowUnderflow = value; + } + } + + public int CodePage { + get { + return codePage; + } + set { + codePage = value; + } + } + + public string DebugType { + get { + return debugType; + } + set { + debugType = value; + } + } + + public string DefineConstants { + get { + return defineConstants; + } + set { + defineConstants = value; + } + } + + public bool DelaySign { + get { + return delaySign; + } + + set { + delaySign = value; + } + } + + public string DisabledWarnings { + get { + return disabledWarnings; + } + set { + disabledWarnings = value; + } + } + + public string DocumentationFile { + get { + return documentationFile; + } + set { + documentationFile = value; + } + } + + public string EmitDebugInformation { + get { + return emitDebugInformation; + } + set { + emitDebugInformation = value; + } + } + + public string KeyContainer { + get { + return keyContainer; + } + set { + keyContainer = value; + } + } + + public string KeyFile { + get { + return keyFile; + } + set { + keyFile = value; + } + } + + public string LangVersion { + get { + return langVersion; + } + set { + langVersion = value; + } + } + + public ITaskItem[] LinkResources { + get { + return linkResources; + } + set { + linkResources = value; + } + } + + public string MainEntryPoint { + get { + return mainEntryPoint; + } + set { + mainEntryPoint = value; + } + } + + public string ModuleAssemblyName { + get { + return moduleAssemblyName; + } + set { + moduleAssemblyName = value; + } + } + + public bool NoConfig { + get { + return noConfig; + } + set { + noConfig = value; + } + } + + public bool NoLogo { + get { + return noLogo; + } + set { + noLogo = value; + } + } + + public bool NoStandardLib { + get { + return noStandardLib; + } + set { + noStandardLib = value; + } + } + + public bool Optimize { + get { + return optimize; + } + set { + optimize = value; + } + } + public ITaskItem OutputAssembly { + get { + return outputAssembly; + } + set { + outputAssembly = value; + } + } + + public ITaskItem[] References { + get { + return references; + } + set { + references = value; + } + } + + public ITaskItem[] Resources { + get { + return resources; + } + set { + resources = value; + } + } + + public ITaskItem[] ResponseFiles { + get { + return responseFiles; + } + set { + responseFiles = value; + } + } + + public ITaskItem[] Sources { + get { + return sources; + } + set { + sources = value; + } + } + + public string TargetType { + get { + return targetType; + } + set { + targetType = value; + } + } + + public bool TreatWarningsAsErrors { + get { + return treatWarningsAsErrors; + } + set { + treatWarningsAsErrors = value; + } + } + + public int WarningLevel { + get { + return warningLevel; + } + set { + warningLevel = value; + } + } + + public string Win32Icon { + get { + return win32Icon; + } + set { + win32Icon = value; + } + } + + public string Win32Resource { + get { + return win32Resource; + } + set { + win32Resource = value; + } + } + + public override bool Execute() + { + string args = GenerateCommandLineArguments(); + + ToolPath = GenerateFullPathToTool(); + MonoCompiler compiler = new MonoCompiler(); + int returnValue = compiler.Run(ToolPath, args, GetCompilerResultsParser()); + + int errorCount = 0; + foreach (CompilerError error in compiler.Results.Errors) { + if (error.IsWarning) { + Log.LogWarning("warning", error.ErrorNumber, null, error.FileName, error.Line, error.Column, error.Line, error.Column, error.ErrorText); + } else { + errorCount++; + Log.LogError("error", error.ErrorNumber, null, error.FileName, error.Line, error.Column, error.Line, error.Column, error.ErrorText); + } + } + + if (returnValue != 0 && errorCount == 0) { + Log.LogError(String.Concat("Failed to execute compiler: ", returnValue, ": ", ToolPath)); + } + + return errorCount == 0; + } + + /// + /// Command line arguments that will be passed to the compiler. + /// + protected virtual string GenerateCommandLineArguments() + { + CompilerCommandLineArguments args = new CompilerCommandLineArguments(this); + return args.ToString(); + } + + protected virtual ICompilerResultsParser GetCompilerResultsParser() + { + return new CompilerResultsParser(); + } + } +} diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.CSharp.targets b/src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.CSharp.targets index e19571fefa..47b0721a71 100644 --- a/src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.CSharp.targets +++ b/src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.CSharp.targets @@ -4,10 +4,12 @@ $(SystemRoot)\Microsoft.NET\Framework\v1.0.3705 true + true $(SystemRoot)\Microsoft.NET\Framework\v1.1.4322 true + true @@ -18,8 +20,12 @@ + + true + + - + @@ -44,7 +50,7 @@ - + @@ -58,4 +64,8 @@ + + + + diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.Mono.Gmcs.targets b/src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.Mono.Gmcs.targets new file mode 100644 index 0000000000..aaf730b594 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.Mono.Gmcs.targets @@ -0,0 +1,63 @@ + + + + + + $(MSBuildAllProjects);$(SharpDevelopBinPath)\SharpDevelop.Build.Mono.targets + .cs + C# + + + + + + + + + + diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.Mono.Mcs.targets b/src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.Mono.Mcs.targets new file mode 100644 index 0000000000..87eb6ed753 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Project/SharpDevelop.Build.Mono.Mcs.targets @@ -0,0 +1,63 @@ + + + + + + $(MSBuildAllProjects);$(SharpDevelopBinPath)\SharpDevelop.Build.Mono.targets + .cs + C# + + + + + + + + + + diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Test/AssemblyInfo.cs b/src/Libraries/ICSharpCode.Build.Tasks/Test/AssemblyInfo.cs new file mode 100644 index 0000000000..906720da13 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Test/AssemblyInfo.cs @@ -0,0 +1,27 @@ +using System.Reflection; +using System.Runtime.CompilerServices; + +// Information about this assembly is defined by the following +// attributes. +// +// change them to the information which is associated with the assembly +// you compile. + +[assembly: AssemblyTitle("")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("")] +[assembly: AssemblyCopyright("")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// The assembly version has following format : +// +// Major.Minor.Build.Revision +// +// You can specify all values by your own or you can build default build and revision +// numbers with the '*' character (the default): + +[assembly: AssemblyVersion("1.0.*")] + diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Test/CompilerCommandLineTestFixture.cs b/src/Libraries/ICSharpCode.Build.Tasks/Test/CompilerCommandLineTestFixture.cs new file mode 100644 index 0000000000..18c8f4baf1 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Test/CompilerCommandLineTestFixture.cs @@ -0,0 +1,273 @@ +// +// 2002-2005 AlphaSierraPapa +// GNU General Public License +// +// $Revision$ +// + +using ICSharpCode.Build.Tasks; +using MbUnit.Framework; +using Microsoft.Build.Utilities; +using System; +using System.Collections.Generic; + +namespace ICSharpCode.Build.Tasks.Tests +{ + [TestFixture] + public class CompilerCommandLineTestFixture + { + [Test] + public void NoArguments() + { + Mcs mcs = new Mcs(); + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0", args.ToString()); + } + + [Test] + public void OutputAssembly() + { + Mcs mcs = new Mcs(); + string outputAssembly = @"obj\debug\test.exe"; + mcs.OutputAssembly = new TaskItem(outputAssembly); + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual(@"-warn:0 -out:obj\debug\test.exe", args.ToString()); + } + + [Test] + public void OutputAssemblyWithSpace() + { + Mcs mcs = new Mcs(); + string outputAssembly = @"obj\debug\test this.exe"; + mcs.OutputAssembly = new TaskItem(outputAssembly); + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -out:\"obj\\debug\\test this.exe\"", args.ToString()); + } + + [Test] + public void WinExeTarget() + { + Mcs mcs = new Mcs(); + mcs.TargetType = "Exe"; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -target:exe", args.ToString()); + } + + [Test] + public void ModuleTarget() + { + Mcs mcs = new Mcs(); + mcs.TargetType = "Module"; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -target:module", args.ToString()); + } + + [Test] + public void FullDebugging() + { + Mcs mcs = new Mcs(); + mcs.DebugType = "Full"; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -debug", args.ToString()); + } + + [Test] + public void Optimize() + { + Mcs mcs = new Mcs(); + mcs.Optimize = true; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -optimize", args.ToString()); + } + + [Test] + public void NoLogo() + { + Mcs mcs = new Mcs(); + mcs.NoLogo = true; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -nologo", args.ToString()); + } + + [Test] + public void Unsafe() + { + Mcs mcs = new Mcs(); + mcs.AllowUnsafeBlocks = true; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -unsafe", args.ToString()); + } + + [Test] + public void NoStandardLib() + { + Mcs mcs = new Mcs(); + mcs.NoStandardLib = true; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -nostdlib", args.ToString()); + } + + [Test] + public void DelaySign() + { + Mcs mcs = new Mcs(); + mcs.DelaySign = true; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -delaysign", args.ToString()); + } + + [Test] + public void DefineConstants() + { + Mcs mcs = new Mcs(); + mcs.DefineConstants = "DEBUG;TRACE"; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -define:\"DEBUG;TRACE\"", args.ToString()); + } + + [Test] + public void WarnAsError() + { + Mcs mcs = new Mcs(); + mcs.TreatWarningsAsErrors = true; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -warnaserror", args.ToString()); + } + + [Test] + public void NoWarn() + { + Mcs mcs = new Mcs(); + mcs.DisabledWarnings = "1234,5678"; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -nowarn:\"1234,5678\"", args.ToString()); + } + + [Test] + public void MainEntryPoint() + { + Mcs mcs = new Mcs(); + mcs.MainEntryPoint = "Console.MainClass.Main"; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -main:Console.MainClass.Main", args.ToString()); + } + + [Test] + public void DocumentationFile() + { + Mcs mcs = new Mcs(); + mcs.DocumentationFile = @"obj\debug test\test.exe.xml"; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -doc:\"obj\\debug test\\test.exe.xml\"", args.ToString()); + } + + [Test] + public void SingleSourceFile() + { + Mcs mcs = new Mcs(); + mcs.Sources = new TaskItem[] { new TaskItem("proj src\\Main.cs") }; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 \"proj src\\Main.cs\"", args.ToString()); + } + + [Test] + public void MultipleSourceFiles() + { + Mcs mcs = new Mcs(); + mcs.Sources = new TaskItem[] { new TaskItem("proj src\\Main.cs"), + new TaskItem("AssemblyInfo.cs") }; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 \"proj src\\Main.cs\" AssemblyInfo.cs", args.ToString()); + } + + [Test] + public void SingleReference() + { + Mcs mcs = new Mcs(); + mcs.References = new TaskItem[] { new TaskItem("proj refs\\Test.dll") }; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -r:\"proj refs\\Test.dll\"", args.ToString()); + } + + [Test] + public void NetModuleReference() + { + Mcs mcs = new Mcs(); + mcs.References = new TaskItem[] { new TaskItem("proj refs\\Test.dll"), + new TaskItem("proj refs\\Run.netmodule") }; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -r:\"proj refs\\Test.dll\" -addmodule:\"proj refs\\Run.netmodule\"", args.ToString()); + } + + [Test] + public void AdditionalLibPaths() + { + Mcs mcs = new Mcs(); + mcs.AdditionalLibPaths = new string[] { "proj\\My libs", "proj\\My libs2" }; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -lib:\"proj\\My libs\",\"proj\\My libs2\"", args.ToString()); + } + + [Test] + public void EmbeddedResources() + { + Mcs mcs = new Mcs(); + mcs.Resources = new TaskItem[] { new TaskItem("proj res\\Test.xml"), + new TaskItem("proj res\\Run.xml") }; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -resource:\"proj res\\Test.xml\" -resource:\"proj res\\Run.xml\"", args.ToString()); + } + + [Test] + public void Win32Resource() + { + Mcs mcs = new Mcs(); + mcs.Win32Resource = "Project Resources\\Test.res"; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -win32res:\"Project Resources\\Test.res\"", args.ToString()); + } + + [Test] + public void Win32Icon() + { + Mcs mcs = new Mcs(); + mcs.Win32Icon = "Project Icons\\app.ico"; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -win32icon:\"Project Icons\\app.ico\"", args.ToString()); + } + + [Test] + public void Checked() + { + Mcs mcs = new Mcs(); + mcs.CheckForOverflowUnderflow = true; + + CompilerCommandLineArguments args = new CompilerCommandLineArguments(mcs); + Assert.AreEqual("-warn:0 -checked", args.ToString()); + } + } +} diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Test/GeneralErrorParseTestFixture.cs b/src/Libraries/ICSharpCode.Build.Tasks/Test/GeneralErrorParseTestFixture.cs new file mode 100644 index 0000000000..545582e1f6 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Test/GeneralErrorParseTestFixture.cs @@ -0,0 +1,47 @@ +// +// 2002-2005 AlphaSierraPapa +// GNU General Public License +// +// $Revision$ +// + +using ICSharpCode.Build.Tasks; +using MbUnit.Framework; +using System; +using System.Text.RegularExpressions; + +namespace ICSharpCode.Build.Tasks.Tests +{ + [TestFixture] + public class GeneralMonoErrorParseTestFixture + { + Match match; + + [TestFixtureSetUp] + public void FixtureSetUp() + { + string error = "error CS1904: `CS0169' is not a valid warning number"; + + Regex regex = new Regex(CompilerResultsParser.GeneralErrorPattern, RegexOptions.Compiled); + match = regex.Match(error); + } + + [Test] + public void Error() + { + Assert.AreEqual("error", match.Result("${error}")); + } + + [Test] + public void ErrorNumber() + { + Assert.AreEqual("CS1904", match.Result("${number}")); + } + + [Test] + public void ErrorText() + { + Assert.AreEqual("`CS0169' is not a valid warning number", match.Result("${message}")); + } + } +} diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Test/ICSharpCode.Build.Tasks.Tests.csproj b/src/Libraries/ICSharpCode.Build.Tasks/Test/ICSharpCode.Build.Tasks.Tests.csproj new file mode 100644 index 0000000000..2943bf75a8 --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Test/ICSharpCode.Build.Tasks.Tests.csproj @@ -0,0 +1,56 @@ + + + Library + ICSharpCode.Build.Tasks.Tests + ICSharpCode.Build.Tasks.Tests + Debug + AnyCPU + {B7C2A664-B454-4920-AC6E-318F5274B2EF} + False + False + False + Auto + 4194304 + AnyCPU + 4096 + 4 + false + + + ..\..\..\..\bin\ + False + DEBUG;TRACE + true + Full + True + + + bin\Release\ + True + TRACE + False + None + False + + + + + + + + + + + + + + + + + + {4139CCF6-FB49-4A9D-B2CF-331E9EA3198D} + ICSharpCode.Build.Tasks + + + + \ No newline at end of file diff --git a/src/Libraries/ICSharpCode.Build.Tasks/Test/NormalMonoErrorParseTestFixture.cs b/src/Libraries/ICSharpCode.Build.Tasks/Test/NormalMonoErrorParseTestFixture.cs new file mode 100644 index 0000000000..38a30cba7c --- /dev/null +++ b/src/Libraries/ICSharpCode.Build.Tasks/Test/NormalMonoErrorParseTestFixture.cs @@ -0,0 +1,65 @@ +// +// 2002-2005 AlphaSierraPapa +// GNU General Public License +// +// $Revision$ +// + +using ICSharpCode.Build.Tasks; +using MbUnit.Framework; +using System; +using System.Text.RegularExpressions; + +namespace ICSharpCode.Build.Tasks.Tests +{ + [TestFixture] + public class NormalMonoErrorParseTestFixture + { + Match match; + + [TestFixtureSetUp] + public void FixtureSetUp() + { + string error = "MyClass.cs(19,7): warning CS0169: The private field `Foo.MyClass.foo' is never used"; + + Regex regex = new Regex(CompilerResultsParser.NormalErrorPattern, RegexOptions.Compiled); + match = regex.Match(error); + } + + [Test] + public void Column() + { + Assert.AreEqual("7", match.Result("${column}")); + } + + [Test] + public void Line() + { + Assert.AreEqual("19", match.Result("${line}")); + } + + [Test] + public void FileName() + { + Assert.AreEqual("MyClass.cs", match.Result("${file}")); + } + + [Test] + public void Warning() + { + Assert.AreEqual("warning", match.Result("${error}")); + } + + [Test] + public void ErrorNumber() + { + Assert.AreEqual("CS0169", match.Result("${number}")); + } + + [Test] + public void ErrorText() + { + Assert.AreEqual("The private field `Foo.MyClass.foo' is never used", match.Result("${message}")); + } + } +} diff --git a/src/Main/Base/Project/Src/Gui/Dialogs/OptionPanels/ProjectOptions/AbstractBuildOptions.cs b/src/Main/Base/Project/Src/Gui/Dialogs/OptionPanels/ProjectOptions/AbstractBuildOptions.cs index 87a6caf359..a3c77b2741 100644 --- a/src/Main/Base/Project/Src/Gui/Dialogs/OptionPanels/ProjectOptions/AbstractBuildOptions.cs +++ b/src/Main/Base/Project/Src/Gui/Dialogs/OptionPanels/ProjectOptions/AbstractBuildOptions.cs @@ -178,7 +178,9 @@ namespace ICSharpCode.SharpDevelop.Gui.OptionPanels new StringPair("", "Default (.NET 2.0)"), new StringPair("v1.0", ".NET 1.0"), new StringPair("v1.1", ".NET 1.1"), - new StringPair("v2.0", ".NET 2.0")); + new StringPair("v2.0", ".NET 2.0"), + new StringPair("Mono v1.1", "Mono 1.1"), + new StringPair("Mono v2.0", "Mono 2.0")); debugInfoBinding.CreateLocationButton("targetFrameworkLabel"); helper.Saved += delegate { // Test if SharpDevelop-Build extensions are needed diff --git a/src/Main/StartUp/Project/Resources/BitmapResources.resources b/src/Main/StartUp/Project/Resources/BitmapResources.resources index 7af98aca3d9e51121cdcb8fb94e5fc4ca8c39071..37caf3af3053ca17bc0abc2061d101e89719576f 100644 GIT binary patch delta 5046 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 delta 953 zcmY+BZD`w76voea(tl|(8*Qw?W=-wOv|ZAdbRiXHv0Il~=gTUNNo!zIV>{niY|R=` z5Xvadjg7%|9;(zX-Kw&wF#jK-f`Z6~16Ns+z9dl|^)G_ZEUoefDh>eHM!MX(7_nrhby-W0?TCGp; zAvMqtwKshLqTh(t)cJ1FDrJ+za;^t%P` z2d8B)iyp(7Ch}cBUM82aC^Nj8b>7URWF9UwriIVIt8ZE+D@$-l?>x2`?ZpzSi|}Dr zT5g+#S57YIEV+5q@*e41L_mBCsO0CQYXRLDE4D70n)r2#1*CHk4trFmK0t9g`ag5= zJJ$KI@saKk7Tu#+c}_TGqYDmvo|dlU^=9Qu@E8}hYirRZ{Y!8fg&SJ5=4-c99^R|TD_UDHmB1}dyidWMGd z9H&l=w-&L)o`=H-YyH5wPF;bUACb8$=r0}6c-vDlp6A=8Ygu37h1847c