public static IEnumerable <string> GetDefinedSymbols(MonoDevelop.Projects.Project project) { var workspace = IdeApp.Workspace; if (workspace == null || project == null) { yield break; } var configuration = project.GetConfiguration(workspace.ActiveConfiguration) as DotNetProjectConfiguration; if (configuration != null) { var cparams = configuration.CompilationParameters as CSharpCompilerParameters; if (cparams != null) { string[] syms = cparams.DefineSymbols.Split(';', ',', ' ', '\t'); foreach (string s in syms) { string ss = s.Trim(); if (ss.Length > 0) { yield return(ss); } } } // Workaround for mcs defined symbol if (configuration.TargetRuntime.RuntimeId == "Mono") { yield return("__MonoCS__"); } } }
public static ICSharpCode.NRefactory.CSharp.CompilerSettings GetCompilerArguments(MonoDevelop.Projects.Project project) { var compilerArguments = new ICSharpCode.NRefactory.CSharp.CompilerSettings(); // compilerArguments.TabSize = 1; if (project == null || MonoDevelop.Ide.IdeApp.Workspace == null) { compilerArguments.AllowUnsafeBlocks = true; return(compilerArguments); } var configuration = project.GetConfiguration(MonoDevelop.Ide.IdeApp.Workspace.ActiveConfiguration) as DotNetProjectConfiguration; if (configuration == null) { return(compilerArguments); } foreach (var sym in configuration.GetDefineSymbols()) { compilerArguments.ConditionalSymbols.Add(sym); } var par = configuration.CompilationParameters as CSharpCompilerParameters; if (par == null) { return(compilerArguments); } compilerArguments.AllowUnsafeBlocks = par.UnsafeCode; compilerArguments.LanguageVersion = ConvertLanguageVersion(par.LangVersion); compilerArguments.CheckForOverflow = par.GenerateOverflowChecks; compilerArguments.WarningLevel = par.WarningLevel; compilerArguments.TreatWarningsAsErrors = par.TreatWarningsAsErrors; if (!string.IsNullOrEmpty(par.NoWarnings)) { foreach (var warning in par.NoWarnings.Split(';', ',', ' ', '\t')) { int w; try { w = int.Parse(warning); } catch (Exception) { continue; } compilerArguments.DisabledWarnings.Add(w); } } return(compilerArguments); }
public static CompilerSettings GetCompilerArguments(MonoDevelop.Projects.Project project) { var compilerArguments = new CompilerSettings(); compilerArguments.TabSize = 1; if (project == null || MonoDevelop.Ide.IdeApp.Workspace == null) { compilerArguments.Unsafe = true; return(compilerArguments); } var configuration = project.GetConfiguration(MonoDevelop.Ide.IdeApp.Workspace.ActiveConfiguration) as DotNetProjectConfiguration; var par = configuration != null ? configuration.CompilationParameters as CSharpCompilerParameters : null; if (par == null) { return(compilerArguments); } if (!string.IsNullOrEmpty(par.DefineSymbols)) { foreach (var sym in par.DefineSymbols.Split(';', ',', ' ', '\t').Where(s => !string.IsNullOrWhiteSpace(s))) { compilerArguments.AddConditionalSymbol(sym); } } compilerArguments.Unsafe = par.UnsafeCode; compilerArguments.Version = ConvertLanguageVersion(par.LangVersion); compilerArguments.Checked = par.GenerateOverflowChecks; compilerArguments.WarningLevel = par.WarningLevel; compilerArguments.EnhancedWarnings = par.TreatWarningsAsErrors; if (!string.IsNullOrEmpty(par.NoWarnings)) { foreach (var warning in par.NoWarnings.Split(';', ',', ' ', '\t')) { int w; try { w = int.Parse(warning); } catch (Exception) { continue; } compilerArguments.SetIgnoreWarning(w); } } return(compilerArguments); }
public static CSharpParseOptions GetCompilerArguments(MonoDevelop.Projects.Project project) { var compilerArguments = new CSharpParseOptions(); // compilerArguments.TabSize = 1; if (project == null || MonoDevelop.Ide.IdeApp.Workspace == null) { // compilerArguments.AllowUnsafeBlocks = true; return(compilerArguments); } var configuration = project.GetConfiguration(MonoDevelop.Ide.IdeApp.Workspace.ActiveConfiguration) as DotNetProjectConfiguration; if (configuration == null) { return(compilerArguments); } compilerArguments = compilerArguments.WithPreprocessorSymbols(configuration.GetDefineSymbols()); var par = configuration.CompilationParameters as CSharpCompilerParameters; if (par == null) { return(compilerArguments); } // compilerArguments.AllowUnsafeBlocks = par.UnsafeCode; compilerArguments = compilerArguments.WithLanguageVersion(ConvertLanguageVersion(par.LangVersion)); // compilerArguments.CheckForOverflow = par.GenerateOverflowChecks; // compilerArguments.WarningLevel = par.WarningLevel; // compilerArguments.TreatWarningsAsErrors = par.TreatWarningsAsErrors; // if (!string.IsNullOrEmpty (par.NoWarnings)) { // foreach (var warning in par.NoWarnings.Split (';', ',', ' ', '\t')) { // int w; // try { // w = int.Parse (warning); // } catch (Exception) { // continue; // } // compilerArguments.DisabledWarnings.Add (w); // } // } return(compilerArguments); }
public override DeployFileCollection GetProjectDeployFiles (DeployContext ctx, Project project, ConfigurationSelector configuration) { DeployFileCollection deployFiles = new DeployFileCollection (); base.GetProjectDeployFiles (ctx, project, configuration); // Add the compiled output file string outputFile = project.GetOutputFileName (configuration); if (!string.IsNullOrEmpty (outputFile)) deployFiles.Add (new DeployFile (project, outputFile, Path.GetFileName (outputFile), TargetDirectory.ProgramFiles)); // Collect deployable files foreach (ProjectFile file in project.Files) { // skip CopyToOutputDirectory files when it's just a project build, because // MonoDevelop.Project.Projects already copies these files using more subtle overwriting // semantics if (file.CopyToOutputDirectory != FileCopyMode.None) continue; DeployProperties props = new DeployProperties (file); if (props.ShouldDeploy) { DeployFile dp = new DeployFile (file); deployFiles.Add (dp); if (string.Compare (Path.GetFileName (dp.SourcePath), "app.config", true)==0 && string.Compare (Path.GetFileName (dp.RelativeTargetPath), "app.config", true)==0) { string newName = Path.GetFileName (outputFile) + ".config"; dp.RelativeTargetPath = Path.Combine (Path.GetDirectoryName (dp.RelativeTargetPath), newName); } } } foreach (FileCopySet.Item item in project.GetSupportFileList (configuration)) { deployFiles.Add (new DeployFile (project, item.Src, item.Target, TargetDirectory.ProgramFiles)); } DotNetProject netProject = project as DotNetProject; if (netProject != null) { DotNetProjectConfiguration conf = (DotNetProjectConfiguration) project.GetConfiguration (configuration); if (conf.DebugMode) { string mdbFile = netProject.TargetRuntime.GetAssemblyDebugInfoFile (conf.CompiledOutputName); deployFiles.Add (new DeployFile (project, mdbFile, Path.GetFileName (mdbFile), TargetDirectory.ProgramFiles)); } } return deployFiles; }
static async Task <DotNetProjectConfiguration> GetDotNetProjectConfiguration(MonoDevelop.Projects.Project p, string framework) { var dotNetProject = p as DotNetProject; if (dotNetProject == null) { return(null); } var workspace = Runtime.PeekService <RootWorkspace> (); var config = workspace != null?p.GetConfiguration(workspace.ActiveConfiguration) as DotNetProjectConfiguration : p.DefaultConfiguration as DotNetProjectConfiguration; if (config == null || string.IsNullOrEmpty(framework)) { return(config); } return(await dotNetProject.GetConfigurationAsync(config.Name, config.Platform, framework).ConfigureAwait(false)); }
public override DeployFileCollection GetProjectDeployFiles (DeployContext ctx, Project project, ConfigurationSelector configuration) { DeployFileCollection deployFiles = new DeployFileCollection (); base.GetProjectDeployFiles (ctx, project, configuration); // Add the compiled output files ProjectConfiguration pconf = (ProjectConfiguration) project.GetConfiguration (configuration); FilePath outDir = pconf.OutputDirectory; foreach (FilePath file in project.GetOutputFiles (configuration)) { deployFiles.Add (new DeployFile (project, file, file.ToRelative (outDir), TargetDirectory.ProgramFiles)); } FilePath outputFile = project.GetOutputFileName (configuration); // Collect deployable files foreach (ProjectFile file in project.Files) { // skip CopyToOutputDirectory files when it's just a project build, because // MonoDevelop.Project.Projects already copies these files using more subtle overwriting // semantics if (file.CopyToOutputDirectory != FileCopyMode.None) continue; DeployProperties props = new DeployProperties (file); if (props.ShouldDeploy) { DeployFile dp = new DeployFile (file); deployFiles.Add (dp); if (string.Compare (Path.GetFileName (dp.SourcePath), "app.config", true)==0 && string.Compare (Path.GetFileName (dp.RelativeTargetPath), "app.config", true)==0) { string newName = Path.GetFileName (outputFile) + ".config"; dp.RelativeTargetPath = Path.Combine (Path.GetDirectoryName (dp.RelativeTargetPath), newName); } } } foreach (FileCopySet.Item item in project.GetSupportFileList (configuration)) { deployFiles.Add (new DeployFile (project, item.Src, item.Target, TargetDirectory.ProgramFiles)); } return deployFiles; }
public static IEnumerable <string> GetDefinedSymbols(MonoDevelop.Projects.Project project) { var workspace = IdeApp.Workspace; if (workspace == null || project == null) { yield break; } var configuration = project.GetConfiguration(workspace.ActiveConfiguration) as DotNetProjectConfiguration; if (configuration != null) { foreach (string s in configuration.GetDefineSymbols()) { yield return(s); } // Workaround for mcs defined symbol if (configuration.TargetRuntime.RuntimeId == "Mono") { yield return("__MonoCS__"); } } }
public static string GetCompletionData(Project project, string classPath, string fileName, int position) { if (!PropertyService.HasValue ("HaxeBinding.EnableCompilationServer")) { PropertyService.Set ("HaxeBinding.EnableCompilationServer", true); PropertyService.Set ("HaxeBinding.CompilationServerPort", 6000); PropertyService.SaveProperties(); } string exe = "haxe"; string args = ""; if (project is NMEProject) { NMEProjectConfiguration configuration = project.GetConfiguration (MonoDevelop.Ide.IdeApp.Workspace.ActiveConfiguration) as NMEProjectConfiguration; string platform = configuration.Platform.ToLower (); string path = ((NMEProject)project).TargetNMMLFile; if (!File.Exists (path)) { path = Path.Combine (project.BaseDirectory, path); } DateTime time = File.GetLastWriteTime (Path.GetFullPath (path)); if (!time.Equals (cacheNMMLTime) || platform != cachePlatform || configuration.AdditionalArguments != cacheArgumentsPlatform || ((NMEProject)project).AdditionalArguments != cacheArgumentsGlobal) { cacheHXML = NMECommandLineToolsManager.GetHXMLData ((NMEProject)project, configuration); cacheNMMLTime = time; cachePlatform = platform; cacheArgumentsGlobal = ((NMEProject)project).AdditionalArguments; cacheArgumentsPlatform = configuration.AdditionalArguments; } args = cacheHXML + " -D code_completion"; } else if (project is HaxeProject) { HaxeProjectConfiguration configuration = project.GetConfiguration (MonoDevelop.Ide.IdeApp.Workspace.ActiveConfiguration) as HaxeProjectConfiguration; args = "\"" + ((HaxeProject)project).TargetHXMLFile + "\" " + ((HaxeProject)project).AdditionalArguments + " " + configuration.AdditionalArguments; } else { return ""; } args += " -cp \"" + classPath + "\" --display \"" + fileName + "\"@" + position + " -D use_rtti_doc"; if (PropertyService.Get<bool> ("HaxeBinding.EnableCompilationServer")) { var port = PropertyService.Get<int> ("HaxeBinding.CompilationServerPort"); if (compilationServer == null || compilationServer.HasExited || port != compilationServerPort) { StartServer (); } try { if (!compilationServer.HasExited) { var client = new TcpClient("127.0.0.1", port); var writer = new StreamWriter(client.GetStream()); writer.WriteLine("--cwd " + project.BaseDirectory); string[] argList = args.Split (' '); foreach (var arg in argList) writer.WriteLine(arg); //writer.WriteLine("--connect " + port); writer.Write("\0"); writer.Flush(); var reader = new StreamReader(client.GetStream()); var lines = reader.ReadToEnd().Split('\n'); client.Close(); return String.Join ("\n", lines); } } catch(Exception) { //MonoDevelop.Ide.MessageService.ShowError (ex.ToString ()); //TraceManager.AddAsync(ex.Message); //if (!failure && FallbackNeeded != null) // FallbackNeeded(false); //failure = true; //return ""; } } //MonoDevelop.Ide.MessageService.ShowError ("Falling back to standard completion"); Process process = new Process (); process.StartInfo.FileName = exe; process.StartInfo.Arguments = args; process.StartInfo.UseShellExecute = false; process.StartInfo.CreateNoWindow = true; process.StartInfo.RedirectStandardError = true; process.StartInfo.WorkingDirectory = project.BaseDirectory; process.Start (); string result = process.StandardError.ReadToEnd (); process.WaitForExit (); return result; }
static DotNetProjectConfiguration GetDotNetProjectConfiguration(MonoDevelop.Projects.Project p) { var workspace = Runtime.PeekService <RootWorkspace> (); return(workspace != null?p.GetConfiguration(workspace.ActiveConfiguration) as MonoDevelop.Projects.DotNetProjectConfiguration : p.DefaultConfiguration as MonoDevelop.Projects.DotNetProjectConfiguration); }
internal async Task <ProjectInfo> LoadProject(MonoDevelop.Projects.Project p, CancellationToken token, MonoDevelop.Projects.Project oldProject) { var projectId = projectMap.GetOrCreateId(p, oldProject); var config = IdeApp.Workspace != null?p.GetConfiguration(IdeApp.Workspace.ActiveConfiguration) as MonoDevelop.Projects.DotNetProjectConfiguration : null; MonoDevelop.Projects.DotNetCompilerParameters cp = config?.CompilationParameters; FilePath fileName = IdeApp.Workspace != null?p.GetOutputFileName(IdeApp.Workspace.ActiveConfiguration) : (FilePath)""; if (fileName.IsNullOrEmpty) { fileName = new FilePath(p.Name + ".dll"); } if (!hackyCache.TryGetCachedItems(p, workspace.MetadataReferenceManager, projectMap, out var sourceFiles, out var analyzerFiles, out var references, out var projectReferences)) { (references, projectReferences) = await metadataHandler.Value.CreateReferences(p, token).ConfigureAwait(false); if (token.IsCancellationRequested) { return(null); } sourceFiles = await p.GetSourceFilesAsync(config?.Selector).ConfigureAwait(false); if (token.IsCancellationRequested) { return(null); } analyzerFiles = await p.GetAnalyzerFilesAsync(config?.Selector).ConfigureAwait(false); if (config != null) { hackyCache.Update(config, p, projectMap, sourceFiles, analyzerFiles, references, projectReferences); } } if (token.IsCancellationRequested) { return(null); } var loader = workspace.Services.GetService <IAnalyzerService> ().GetLoader(); ProjectData projectData, oldProjectData; List <DocumentInfo> mainDocuments, additionalDocuments; try { await workspace.LoadLock.WaitAsync().ConfigureAwait(false); //when reloading e.g. after a save, preserve document IDs oldProjectData = projectMap.RemoveData(projectId); projectData = projectMap.CreateData(projectId, references); var documents = await CreateDocuments(projectData, p, token, sourceFiles, oldProjectData).ConfigureAwait(false); if (documents == null) { return(null); } mainDocuments = documents.Item1; additionalDocuments = documents.Item2; } finally { workspace.LoadLock.Release(); } // TODO: Pass in the WorkspaceMetadataFileReferenceResolver var info = ProjectInfo.Create( projectId, VersionStamp.Create(), p.Name, fileName.FileNameWithoutExtension, (p as MonoDevelop.Projects.DotNetProject)?.RoslynLanguageName ?? LanguageNames.CSharp, p.FileName, fileName, cp?.CreateCompilationOptions(), cp?.CreateParseOptions(config), mainDocuments, projectReferences, references.Select(x => x.CurrentSnapshot), analyzerReferences: analyzerFiles.SelectAsArray(x => { var analyzer = new MonoDevelopAnalyzer(x, hostDiagnosticUpdateSource.Value, projectId, workspace, loader, LanguageNames.CSharp); analyzersToDispose.Add(analyzer); return(analyzer.GetReference()); }), additionalDocuments: additionalDocuments ); return(info); }