/// <summary> /// Cleans up intermediate files /// </summary> /// <param name="projectFiles"> /// The project's files /// <see cref="ProjectFileCollection"/> /// </param> /// <param name="configuration"> /// Project configuration /// <see cref="ValaProjectConfiguration"/> /// </param> /// <param name="monitor"> /// The progress monitor to be used /// <see cref="IProgressMonitor"/> /// </param> public void Clean(ProjectFileCollection projectFiles, ValaProjectConfiguration configuration, IProgressMonitor monitor) { /// Clean up intermediate files /// These should only be generated for libraries, but we'll check for them in all cases foreach (ProjectFile file in projectFiles) { if (file.BuildAction == BuildAction.Compile) { string cFile = Path.Combine(configuration.OutputDirectory, Path.GetFileNameWithoutExtension(file.Name) + ".c"); if (File.Exists(cFile)) { File.Delete(cFile); } string hFile = Path.Combine(configuration.OutputDirectory, Path.GetFileNameWithoutExtension(file.Name) + ".h"); if (File.Exists(hFile)) { File.Delete(hFile); } } } string vapiFile = Path.Combine(configuration.OutputDirectory, configuration.Output + ".vapi"); if (File.Exists(vapiFile)) { File.Delete(vapiFile); } }
/// <summary> /// This is the pkg-config package that gets deployed. /// <returns>The pkg-config package's filename</returns> /// </summary> private string WriteDeployablePkgPackage(ConfigurationSelector configuration) { // FIXME: This should probably be grabed from somewhere. string prefix = "/usr/local"; string pkgfile = Path.Combine(BaseDirectory, Name + ".pc"); ValaProjectConfiguration config = (ValaProjectConfiguration)GetConfiguration(configuration); using (StreamWriter writer = new StreamWriter(pkgfile)) { writer.WriteLine("prefix={0}", prefix); writer.WriteLine("exec_prefix=${prefix}"); writer.WriteLine("libdir=${exec_prefix}/lib"); writer.WriteLine("includedir=${prefix}/include"); writer.WriteLine(); writer.WriteLine("Name: {0}", Name); writer.WriteLine("Description: {0}", Description); writer.WriteLine("Version: {0}", Version); writer.WriteLine("Requires: {0}", string.Join(" ", Packages.ToStringArray())); // TODO: How should I get this? writer.WriteLine("Conflicts: {0}", string.Empty); writer.Write("Libs: -L${libdir} "); writer.WriteLine("-l{0}", config.Output); writer.Write("Cflags: -I${includedir}/"); writer.WriteLine("{0} {1}", Name, Regex.Replace(((ValaCompilationParameters)config.CompilationParameters).DefineSymbols, @"(^|\s+)(\w+)", "-D$2 ", RegexOptions.Compiled)); } return(pkgfile); }
/// <summary> /// Ths pkg-config package is for internal MonoDevelop use only, it is not deployed. /// </summary> public void WriteMDPkgPackage(ConfigurationSelector configuration) { string pkgfile = Path.Combine(BaseDirectory, Name + ".md.pc"); ValaProjectConfiguration config = (ValaProjectConfiguration)GetConfiguration(configuration); using (StreamWriter writer = new StreamWriter(pkgfile)) { writer.WriteLine("Name: {0}", Name); writer.WriteLine("Description: {0}", Description); writer.WriteLine("Version: {0}", Version); writer.WriteLine("Libs: -L{0} -l{1}", config.OutputDirectory, config.Output); // writer.WriteLine ("Cflags: -I{0}", BaseDirectory); } // If this project compiles into a shared object we need to // export the output path to the LD_LIBRARY_PATH string literal = "LD_LIBRARY_PATH"; string ld_library_path = Environment.GetEnvironmentVariable(literal); if (string.IsNullOrEmpty(ld_library_path)) { Environment.SetEnvironmentVariable(literal, config.OutputDirectory); } else if (!ld_library_path.Contains(config.OutputDirectory)) { ld_library_path = string.Format("{0}:{1}", config.OutputDirectory, ld_library_path); Environment.SetEnvironmentVariable(literal, ld_library_path); } }
protected override bool OnGetCanExecute(MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector solutionConfiguration) { ValaProjectConfiguration conf = (ValaProjectConfiguration)GetConfiguration(solutionConfiguration); ExecutionCommand cmd = CreateExecutionCommand(conf); return((conf.CompileTarget == ValaBinding.CompileTarget.Bin) && context.ExecutionHandler.CanExecute(cmd)); }
public ProjectPackage(ValaProject project) : this() { name = project.Name; ValaProjectConfiguration vpc = (ValaProjectConfiguration)(project.DefaultConfiguration); file = Path.Combine(vpc.OutputDirectory, name + ".vapi"); is_project = true; }
/// <summary> /// Add dependencies of project packages to current project, /// and add cflags for project package and LD_LIBRARY_PATH /// </summary> private void AddDependencies(object obj, ProjectPackageEventArgs args) { ProjectPackage package = args.Package; if (!package.IsProject) { return; } string depsfile = Path.ChangeExtension(package.File, ".deps"); try { if (File.Exists(depsfile)) { string[] lines = File.ReadAllLines(depsfile); List <ProjectPackage> deps = new List <ProjectPackage>(); foreach (string line in lines) { deps.Add(new ProjectPackage(Path.Combine(vapidir, line) + ".vapi")); } // add package for each dep packages.AddRange(deps); } // Currently, we need to add include directory and linker flags - this should be obsoleted string ccargs = string.Format(" --Xcc=\\\\\\\"-I{0}\\\\\\\" --Xcc=\\\\\\\"-L{0}\\\\\\\" --Xcc=\\\\\\\"-l{1}\\\\\\\" ", Path.GetDirectoryName(depsfile), package.Name); string ldpath = string.Empty; string packagePath = Path.GetDirectoryName(package.File); foreach (ItemConfiguration pc in Configurations) { ValaProjectConfiguration valapc = pc as ValaProjectConfiguration; if (null == valapc) { continue; } ValaCompilationParameters vcp = (ValaCompilationParameters)valapc.CompilationParameters; if (!vcp.ExtraCompilerArguments.Contains(ccargs)) { vcp.ExtraCompilerArguments += ccargs; } if (valapc.EnvironmentVariables.TryGetValue("LD_LIBRARY_PATH", out ldpath)) { if (!ldpath.Contains(packagePath)) { ldpath += Path.PathSeparator + packagePath; } } else { ldpath = packagePath; } valapc.EnvironmentVariables["LD_LIBRARY_PATH"] = ldpath; } // add compilation parameters and LD_LIBRARY_PATH } catch { /* Do anything here? */ } } // AddDependencies
ExecutionCommand CreateExecutionCommand(ValaProjectConfiguration conf) { NativeExecutionCommand cmd = new NativeExecutionCommand(); cmd.Command = Path.Combine(conf.OutputDirectory, conf.Output); cmd.Arguments = conf.CommandLineParameters; cmd.WorkingDirectory = Path.GetFullPath(conf.OutputDirectory); return(cmd); }
public override SolutionItemConfiguration CreateConfiguration(string name) { ValaProjectConfiguration conf = new ValaProjectConfiguration(); conf.Name = name; conf.CompilationParameters = new ValaCompilationParameters(); return(conf); }
/// <summary> /// Deploys a makefile to build the default configuration. /// </summary> /// <remarks> /// TODO: Make configuration-based targets as advertised. /// </remarks> public Makefile Deploy(AutotoolsContext ctx, MonoDevelop.Projects.SolutionItem entry, MonoDevelop.Core.IProgressMonitor monitor) { Makefile mkfile = new Makefile(); ValaProject project = (ValaProject)entry; ValaProjectConfiguration conf = (ValaProjectConfiguration)project.DefaultConfiguration; StringBuilder files = new StringBuilder(); foreach (ProjectFile t in project.Files) { if (BuildAction.Compile == t.BuildAction) { files.Append("\\\n\t" + FileService.AbsoluteToRelativePath(project.BaseDirectory, t.FilePath)); } } string dir = ctx.DeployContext.GetResolvedPath(TargetDirectory.ProgramFiles, FileService.AbsoluteToRelativePath(conf.OutputDirectory, ctx.TargetSolution.BaseDirectory)); dir = dir.Replace("@prefix@", "$(prefix)"); dir = dir.Replace("@PACKAGE@", "$(PACKAGE)"); TemplateEngine templateEngine = new TemplateEngine(); templateEngine.Variables ["TOP_SRCDIR"] = FileService.AbsoluteToRelativePath(project.BaseDirectory, ctx.TargetSolution.BaseDirectory); templateEngine.Variables ["FILES"] = files.ToString(); templateEngine.Variables ["BUILD_DIR"] = "."; templateEngine.Variables ["INSTALL_DIR"] = "$(DESTDIR)" + dir; templateEngine.Variables ["ALL_TARGET"] = string.Format("all-{0}", conf.Name); templateEngine.Variables ["VFLAGS"] = string.Format("{0} {1}", ValaCompiler.GetCompilerFlags(conf), ValaCompiler.GeneratePkgCompilerArgs(project.Packages)); templateEngine.Variables ["VTARGET"] = conf.CompiledOutputName; StringWriter sw = new StringWriter(); string mt; if (ctx.MakefileType == MakefileType.AutotoolsMakefile) { mt = "Makefile.am.template"; } else { mt = "Makefile.template"; } using (Stream stream = GetType().Assembly.GetManifestResourceStream(mt)) { StreamReader reader = new StreamReader(stream); templateEngine.Process(reader, sw); reader.Close(); } mkfile.Append(sw.ToString()); return(mkfile); }
public void Load(ValaProjectConfiguration config) { configuration = config; compilationParameters = (ValaCompilationParameters)configuration.CompilationParameters; switch (compilationParameters.WarningLevel) { case WarningLevel.None: noWarningRadio.Active = true; break; case WarningLevel.Normal: normalWarningRadio.Active = true; break; case WarningLevel.All: allWarningRadio.Active = true; break; } warningsAsErrorsCheckBox.Active = compilationParameters.WarningsAsErrors; threadingCheckbox.Sensitive = (config.CompileTarget == CompileTarget.Bin); threadingCheckbox.Active = (threadingCheckbox.Sensitive && compilationParameters.EnableMultithreading); optimizationSpinButton.Value = compilationParameters.OptimizationLevel; switch (configuration.CompileTarget) { case ValaBinding.CompileTarget.Bin: targetComboBox.Active = 0; break; case ValaBinding.CompileTarget.StaticLibrary: targetComboBox.Active = 1; break; case ValaBinding.CompileTarget.SharedLibrary: targetComboBox.Active = 2; break; } extraCompilerTextView.Buffer.Text = compilationParameters.ExtraCompilerArguments; defineSymbolsTextEntry.Text = compilationParameters.DefineSymbols; foreach (string lib in configuration.Libs) { libStore.AppendValues(lib); } foreach (string includePath in configuration.Includes) { includePathStore.AppendValues(includePath); } }
public void Load(ValaProjectConfiguration config) { configuration = config; outputNameTextEntry.Text = configuration.Output; outputPathTextEntry.Text = configuration.OutputDirectory; parametersTextEntry.Text = configuration.CommandLineParameters; externalConsoleCheckbox.Active = configuration.ExternalConsole; pauseCheckbox.Active = configuration.PauseConsoleOutput; }
protected override BuildResult DoBuild(IProgressMonitor monitor, ConfigurationSelector configuration) { ValaProjectConfiguration pc = (ValaProjectConfiguration)GetConfiguration(configuration); pc.SourceDirectory = BaseDirectory; return(compiler_manager.Compile( Files, packages, pc, monitor)); }
public void Load (ValaProjectConfiguration config) { configuration = config; outputNameTextEntry.Text = configuration.Output; outputPathTextEntry.Text = configuration.OutputDirectory; parametersTextEntry.Text = configuration.CommandLineParameters; externalConsoleCheckbox.Active = configuration.ExternalConsole; pauseCheckbox.Active = configuration.PauseConsoleOutput; }
protected override void InsertItem(int index, ProjectPackage value) { if (value.IsProject && null != project) { ValaProjectConfiguration vpc = (ValaProjectConfiguration)project.DefaultConfiguration; value.File = ProjectPackage.ToRelativePath(value.File, Path.Combine(vpc.OutputDirectory, vpc.CompiledOutputName)); } base.InsertItem(index, value); if (project != null) { project.NotifyPackageAddedToProject(value); } }
protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { ValaProjectConfiguration conf = (ValaProjectConfiguration)GetConfiguration(configuration); bool pause = conf.PauseConsoleOutput; IConsole console; if (conf.CompileTarget != ValaBinding.CompileTarget.Bin) { MessageService.ShowMessage("Compile target is not an executable!"); return; } ExecutionCommand cmd = CreateExecutionCommand(conf); monitor.Log.WriteLine("Running project..."); if (conf.ExternalConsole) { console = context.ExternalConsoleFactory.CreateConsole(!pause); } else { console = context.ConsoleFactory.CreateConsole(!pause); } AggregatedOperationMonitor operationMonitor = new AggregatedOperationMonitor(monitor); try { if (!context.ExecutionHandler.CanExecute(cmd)) { monitor.ReportError("Cannot execute \"" + conf.Output + "\". The selected execution mode is not supported for Vala projects.", null); return; } IProcessAsyncOperation op = context.ExecutionHandler.Execute(cmd, console); operationMonitor.AddOperation(op); op.WaitForCompleted(); monitor.Log.WriteLine("The operation exited with code: {0}", op.ExitCode); } catch (Exception ex) { monitor.ReportError("Cannot execute \"" + conf.Output + "\"", ex); } finally { operationMonitor.Dispose(); console.Dispose(); } }
protected override void SetItem(int index, ProjectPackage item) { ProjectPackage oldValue = Items [index]; if (item.IsProject && null != project) { ValaProjectConfiguration vpc = (ValaProjectConfiguration)project.DefaultConfiguration; item.File = ProjectPackage.ToRelativePath(item.File, Path.Combine(vpc.OutputDirectory, vpc.CompiledOutputName)); } base.SetItem(index, item); if (project != null) { project.NotifyPackageRemovedFromProject(oldValue); project.NotifyPackageAddedToProject(item); } }
public void GenerateDepfile(ValaProjectConfiguration configuration, ProjectPackageCollection packages) { try { if (configuration.CompileTarget != CompileTarget.SharedLibrary) { return; } using (StreamWriter writer = new StreamWriter(Path.Combine(configuration.OutputDirectory, Path.ChangeExtension(configuration.Output, ".deps")))) { foreach (ProjectPackage package in packages) { writer.WriteLine(package.Name); } } } catch { /* Don't care */ } }
public void Load (ValaProjectConfiguration config) { configuration = config; compilationParameters = (ValaCompilationParameters)configuration.CompilationParameters; switch (compilationParameters.WarningLevel) { case WarningLevel.None: noWarningRadio.Active = true; break; case WarningLevel.Normal: normalWarningRadio.Active = true; break; case WarningLevel.All: allWarningRadio.Active = true; break; } warningsAsErrorsCheckBox.Active = compilationParameters.WarningsAsErrors; threadingCheckbox.Sensitive = (config.CompileTarget == CompileTarget.Bin); threadingCheckbox.Active = (threadingCheckbox.Sensitive && compilationParameters.EnableMultithreading); optimizationSpinButton.Value = compilationParameters.OptimizationLevel; switch (configuration.CompileTarget) { case ValaBinding.CompileTarget.Bin: targetComboBox.Active = 0; break; case ValaBinding.CompileTarget.StaticLibrary: targetComboBox.Active = 1; break; case ValaBinding.CompileTarget.SharedLibrary: targetComboBox.Active = 2; break; } extraCompilerTextView.Buffer.Text = compilationParameters.ExtraCompilerArguments; defineSymbolsTextEntry.Text = compilationParameters.DefineSymbols; foreach (string lib in configuration.Libs) libStore.AppendValues (lib); foreach (string includePath in configuration.Includes) includePathStore.AppendValues (includePath); }
/// <summary> /// Compile the project /// </summary> /// <param name="projectFiles"> /// Collection of project files /// <see cref="ProjectFileCollection"/> /// </param> /// <param name="packages"> /// Collection of depended packages /// <see cref="ProjectPackageCollection"/> /// </param> /// <param name="configuration"> /// Project configuration /// <see cref="ValaProjectConfiguration"/> /// </param> /// <param name="monitor"> /// Progress monitor to be used /// <see cref="IProgressMonitor"/> /// </param> /// <returns> /// Result of the compilation /// <see cref="ICompilerResult"/> /// </returns> public BuildResult Compile( ProjectFileCollection projectFiles, ProjectPackageCollection packages, ValaProjectConfiguration configuration, IProgressMonitor monitor) { if (!appsChecked) { appsChecked = true; compilerFound = CheckApp(compilerCommand); } /// Check for compiler if (!compilerFound) { BuildResult cres = new BuildResult(); cres.AddError("Compiler not found: " + compilerCommand); return(cres); } /// No compiler! CompilerResults cr = new CompilerResults(new TempFileCollection()); bool success = true; /// Build compiler params string string compilerArgs = GetCompilerFlags(configuration) + " " + GeneratePkgCompilerArgs(packages); /// Build executable name string outputName = Path.Combine(configuration.OutputDirectory, configuration.CompiledOutputName); monitor.BeginTask(GettextCatalog.GetString("Compiling source"), 1); success = DoCompilation(projectFiles, compilerArgs, outputName, monitor, cr); GenerateDepfile(configuration, packages); if (success) { monitor.Step(1); } monitor.EndTask(); return(new BuildResult(cr, "")); }
public override void CopyFrom(ItemConfiguration configuration) { base.CopyFrom(configuration); ValaProjectConfiguration conf = (ValaProjectConfiguration)configuration; output = conf.output; target = conf.target; includes = conf.includes; libs = conf.libs; source_directory_path = conf.source_directory_path; if (conf.CompilationParameters == null) { compilationParameters = null; } else { compilationParameters = (ICloneable)conf.compilationParameters.Clone(); } }
private List <ProjectPackage> GetPackagesOfProjects(Project project) { List <ProjectPackage> packages = new List <ProjectPackage>(); ProjectPackage package; foreach (Project c in IdeApp.Workspace.GetAllProjects()) { if (c is ValaProject) { ValaProject proj = c as ValaProject; ValaProjectConfiguration conf = proj.GetConfiguration(IdeApp.Workspace.ActiveConfiguration) as ValaProjectConfiguration; if (conf.CompileTarget != CompileTarget.Bin) { proj.WriteMDPkgPackage(conf.Selector); package = new ProjectPackage(proj); packages.Add(package); } } } return(packages); }
protected override BuildResult Build(IProgressMonitor monitor, SolutionEntityItem entry, ConfigurationSelector configuration) { ValaProject project = entry as ValaProject; if (project == null) { return(base.Build(monitor, entry, configuration)); } foreach (ValaProject p in project.DependedOnProjects()) { p.Build(monitor, configuration, true); } ValaProjectConfiguration conf = (ValaProjectConfiguration)project.GetConfiguration(configuration); if (conf.CompileTarget != CompileTarget.Bin) { project.WriteMDPkgPackage(configuration); } return(base.Build(monitor, entry, configuration)); }
/// <summary> /// Generates compiler args for the current settings /// </summary> /// <param name="configuration"> /// Project configuration /// <see cref="ValaProjectConfiguration"/> /// </param> /// <returns> /// A compiler-interpretable string /// <see cref="System.String"/> /// </returns> public static string GetCompilerFlags (ValaProjectConfiguration configuration) { List<string> args = new List<string> (); ValaCompilationParameters cp = (ValaCompilationParameters)configuration.CompilationParameters; args.Add (string.Format ("-d '{0}'", configuration.OutputDirectory)); if (configuration.DebugMode) args.Add ("-g"); switch (configuration.CompileTarget) { case ValaBinding.CompileTarget.Bin: if (cp.EnableMultithreading) { args.Add ("--thread"); } break; case ValaBinding.CompileTarget.SharedLibrary: args.Add (string.Format ("--Xcc=\"-shared\" --Xcc=\"-fPIC\" --Xcc=\"-I'{0}'\" -H \"{1}.h\" --library \"{1}\"", configuration.OutputDirectory, configuration.Output)); break; } // Valac will get these sooner or later // switch (cp.WarningLevel) // { // case WarningLevel.None: // args.Append ("-w "); // break; // case WarningLevel.Normal: // // nothing // break; // case WarningLevel.All: // args.Append ("-Wall "); // break; // } // // if (cp.WarningsAsErrors) // args.Append ("-Werror "); // if (0 < cp.OptimizationLevel) { args.Add ("--Xcc=\"-O" + cp.OptimizationLevel + "\""); } if (cp.ExtraCompilerArguments != null && cp.ExtraCompilerArguments.Length > 0) { args.Add (ExpandBacktickedParameters (cp.ExtraCompilerArguments.Replace (Environment.NewLine, " "))); } if (cp.DefineSymbols != null && cp.DefineSymbols.Length > 0) { args.Add (ProcessDefineSymbols (cp.DefineSymbols)); } if (configuration.Includes != null) foreach (string inc in configuration.Includes) args.Add ("--vapidir \"" + inc + "\""); if (configuration.Libs != null) foreach (string lib in configuration.Libs) args.Add ("--pkg \"" + lib + "\""); return string.Join (" ", args.ToArray ()); }
public ValaProject(ProjectCreateInformation info, XmlElement projectOptions, string language) { Init(); string binPath = "."; if (info != null) { Name = info.ProjectName; binPath = info.BinPath; } Compiler = null; ValaProjectConfiguration configuration = (ValaProjectConfiguration)CreateConfiguration("Debug"); configuration.DebugMode = true; ((ValaCompilationParameters)configuration.CompilationParameters).DefineSymbols = "DEBUG MONODEVELOP"; Configurations.Add(configuration); configuration = (ValaProjectConfiguration)CreateConfiguration("Release"); configuration.DebugMode = false; ((ValaCompilationParameters)configuration.CompilationParameters).OptimizationLevel = 3; ((ValaCompilationParameters)configuration.CompilationParameters).DefineSymbols = "MONODEVELOP"; Configurations.Add(configuration); foreach (ValaProjectConfiguration c in Configurations) { c.OutputDirectory = Path.Combine(binPath, c.Name); c.SourceDirectory = info.ProjectBasePath; c.Output = Name; ValaCompilationParameters parameters = c.CompilationParameters as ValaCompilationParameters; if (projectOptions != null) { if (projectOptions.Attributes["Target"] != null) { c.CompileTarget = (ValaBinding.CompileTarget)Enum.Parse( typeof(ValaBinding.CompileTarget), projectOptions.Attributes["Target"].InnerText); } if (projectOptions.Attributes["PauseConsoleOutput"] != null) { c.PauseConsoleOutput = bool.Parse( projectOptions.Attributes["PauseConsoleOutput"].InnerText); } if (projectOptions.Attributes["CompilerArgs"].InnerText != null) { if (parameters != null) { parameters.ExtraCompilerArguments = projectOptions.Attributes["CompilerArgs"].InnerText; } } if (projectOptions.Attributes["Packages"].InnerText != null) { List <ProjectPackage> packs = new List <ProjectPackage>(); foreach (string pack in projectOptions.Attributes["Packages"].InnerText.Split('|')) { packs.Add(new ProjectPackage( string.Format("{0}{1}{2}.vapi", vapidir, Path.DirectorySeparatorChar, pack))); } packages.AddRange(packs); } } } }
public override SolutionItemConfiguration CreateConfiguration (string name) { ValaProjectConfiguration conf = new ValaProjectConfiguration (); conf.Name = name; conf.CompilationParameters = new ValaCompilationParameters (); return conf; }
/// <summary> /// Compile the project /// </summary> /// <param name="projectFiles"> /// Collection of project files /// <see cref="ProjectFileCollection"/> /// </param> /// <param name="packages"> /// Collection of depended packages /// <see cref="ProjectPackageCollection"/> /// </param> /// <param name="configuration"> /// Project configuration /// <see cref="ValaProjectConfiguration"/> /// </param> /// <param name="monitor"> /// Progress monitor to be used /// <see cref="IProgressMonitor"/> /// </param> /// <returns> /// Result of the compilation /// <see cref="ICompilerResult"/> /// </returns> public BuildResult Compile ( ProjectFileCollection projectFiles, ProjectPackageCollection packages, ValaProjectConfiguration configuration, IProgressMonitor monitor) { if (!appsChecked) { appsChecked = true; compilerFound = CheckApp (compilerCommand); }/// Check for compiler if (!compilerFound) { BuildResult cres = new BuildResult (); cres.AddError ("Compiler not found: " + compilerCommand); return cres; }/// No compiler! CompilerResults cr = new CompilerResults (new TempFileCollection ()); bool success = true; /// Build compiler params string string compilerArgs = GetCompilerFlags (configuration) + " " + GeneratePkgCompilerArgs (packages); /// Build executable name string outputName = Path.Combine (configuration.OutputDirectory, configuration.CompiledOutputName); monitor.BeginTask (GettextCatalog.GetString ("Compiling source"), 1); success = DoCompilation (projectFiles, compilerArgs, outputName, monitor, cr); GenerateDepfile (configuration, packages); if (success) monitor.Step (1); monitor.EndTask (); return new BuildResult (cr, ""); }
/// <summary> /// Generates compilers flags for selected defines /// </summary> /// <param name="configuration"> /// Project configuration /// <see cref="ValaProjectConfiguration"/> /// </param> /// <returns> /// A compiler-interpretable string /// <see cref="System.String"/> /// </returns> public string GetDefineFlags(ValaProjectConfiguration configuration) { string defines = ((ValaCompilationParameters)configuration.CompilationParameters).DefineSymbols; return(ProcessDefineSymbols(defines)); }
string ICompiler.GetCompilerFlags (ValaProjectConfiguration configuration) { return ValaCompiler.GetCompilerFlags (configuration); }
string ICompiler.GetCompilerFlags(ValaProjectConfiguration configuration) { return(ValaCompiler.GetCompilerFlags(configuration)); }
/// <summary> /// Generates compiler args for the current settings /// </summary> /// <param name="configuration"> /// Project configuration /// <see cref="ValaProjectConfiguration"/> /// </param> /// <returns> /// A compiler-interpretable string /// <see cref="System.String"/> /// </returns> public static string GetCompilerFlags(ValaProjectConfiguration configuration) { List <string> args = new List <string> (); ValaCompilationParameters cp = (ValaCompilationParameters)configuration.CompilationParameters; args.Add(string.Format("-d '{0}'", configuration.OutputDirectory)); if (configuration.DebugMode) { args.Add("-g"); } switch (configuration.CompileTarget) { case ValaBinding.CompileTarget.Bin: if (cp.EnableMultithreading) { args.Add("--thread"); } break; case ValaBinding.CompileTarget.SharedLibrary: args.Add(string.Format("--Xcc=\"-shared\" --Xcc=\"-fPIC\" --Xcc=\"-I'{0}'\" -H \"{1}.h\" --library \"{1}\"", configuration.OutputDirectory, configuration.Output)); break; } // Valac will get these sooner or later // switch (cp.WarningLevel) // { // case WarningLevel.None: // args.Append ("-w "); // break; // case WarningLevel.Normal: // // nothing // break; // case WarningLevel.All: // args.Append ("-Wall "); // break; // } // // if (cp.WarningsAsErrors) // args.Append ("-Werror "); // if (0 < cp.OptimizationLevel) { args.Add("--Xcc=\"-O" + cp.OptimizationLevel + "\""); } if (cp.ExtraCompilerArguments != null && cp.ExtraCompilerArguments.Length > 0) { args.Add(ExpandBacktickedParameters(cp.ExtraCompilerArguments.Replace(Environment.NewLine, " "))); } if (cp.DefineSymbols != null && cp.DefineSymbols.Length > 0) { args.Add(ProcessDefineSymbols(cp.DefineSymbols)); } if (configuration.Includes != null) { foreach (string inc in configuration.Includes) { args.Add("--vapidir \"" + inc + "\""); } } if (configuration.Libs != null) { foreach (string lib in configuration.Libs) { args.Add("--pkg \"" + lib + "\""); } } return(string.Join(" ", args.ToArray())); }
ExecutionCommand CreateExecutionCommand (ValaProjectConfiguration conf) { NativeExecutionCommand cmd = new NativeExecutionCommand (); cmd.Command = Path.Combine (conf.OutputDirectory, conf.Output); cmd.Arguments = conf.CommandLineParameters; cmd.WorkingDirectory = Path.GetFullPath (conf.OutputDirectory); return cmd; }
public void GenerateDepfile (ValaProjectConfiguration configuration, ProjectPackageCollection packages) { try { if (configuration.CompileTarget != CompileTarget.SharedLibrary){ return; } using (StreamWriter writer = new StreamWriter (Path.Combine (configuration.OutputDirectory, Path.ChangeExtension (configuration.Output, ".deps")))) { foreach (ProjectPackage package in packages) { writer.WriteLine (package.Name); } } } catch { /* Don't care */ } }
/// <summary> /// Generates compilers flags for selected defines /// </summary> /// <param name="configuration"> /// Project configuration /// <see cref="ValaProjectConfiguration"/> /// </param> /// <returns> /// A compiler-interpretable string /// <see cref="System.String"/> /// </returns> public string GetDefineFlags (ValaProjectConfiguration configuration) { string defines = ((ValaCompilationParameters)configuration.CompilationParameters).DefineSymbols; return ProcessDefineSymbols (defines); }
public override FilePath GetOutputFileName(ConfigurationSelector configuration) { ValaProjectConfiguration conf = (ValaProjectConfiguration)GetConfiguration(configuration); return(conf.OutputDirectory.Combine(conf.CompiledOutputName)); }
/// <summary> /// Cleans up intermediate files /// </summary> /// <param name="projectFiles"> /// The project's files /// <see cref="ProjectFileCollection"/> /// </param> /// <param name="configuration"> /// Project configuration /// <see cref="ValaProjectConfiguration"/> /// </param> /// <param name="monitor"> /// The progress monitor to be used /// <see cref="IProgressMonitor"/> /// </param> public void Clean (ProjectFileCollection projectFiles, ValaProjectConfiguration configuration, IProgressMonitor monitor) { /// Clean up intermediate files /// These should only be generated for libraries, but we'll check for them in all cases foreach (ProjectFile file in projectFiles) { if (file.BuildAction == BuildAction.Compile) { string cFile = Path.Combine (configuration.OutputDirectory, Path.GetFileNameWithoutExtension (file.Name) + ".c"); if (File.Exists (cFile)){ File.Delete (cFile); } string hFile = Path.Combine (configuration.OutputDirectory, Path.GetFileNameWithoutExtension (file.Name) + ".h"); if (File.Exists (hFile)){ File.Delete (hFile); } } } string vapiFile = Path.Combine (configuration.OutputDirectory, configuration.Output + ".vapi"); if (File.Exists (vapiFile)){ File.Delete (vapiFile); } }