Exemplo n.º 1
0
        /// <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>
        /// Gets the files that get compiled into object code.
        /// </summary>
        /// <param name="projectFiles">
        /// A <see cref="ProjectFileCollection"/>
        /// The project's files, extracts from here the files that get compiled into object code.
        /// </param>
        /// <param name="configuration">
        /// A <see cref="CProjectConfiguration"/>
        /// The configuration to get the object files for...
        /// </param>
        /// <param name="withQuotes">
        /// A <see cref="System.Boolean"/>
        /// If true, it will surround each object file with quotes
        /// so that gcc has no problem with paths that contain spaces.
        /// </param>
        /// <returns>
        /// An array of strings, each string is the name of a file
        /// that will get compiled into object code. The file name
        /// will already have the .o extension.
        /// </returns>
        private string[] ObjectFiles(ProjectFileCollection projectFiles, CProjectConfiguration configuration, bool withQuotes)
        {
            if (projectFiles.Count == 0)
            {
                return new string[] {}
            }
            ;

            List <string> objectFiles = new List <string> ();

            foreach (ProjectFile f in projectFiles)
            {
                if (f.BuildAction == BuildAction.Compile)
                {
                    string PathName = Path.Combine(configuration.OutputDirectory, Path.GetFileNameWithoutExtension(f.Name) + ".o");

                    if (File.Exists(PathName) == false)
                    {
                        continue;
                    }

                    if (!withQuotes)
                    {
                        objectFiles.Add(PathName);
                    }
                    else
                    {
                        objectFiles.Add("\"" + PathName + "\"");
                    }
                }
            }

            return(objectFiles.ToArray());
        }
        private void MakeStaticLibrary(Project project,
                                       ProjectFileCollection projectFiles,
                                       CProjectConfiguration configuration,
                                       ProjectPackageCollection packages,
                                       CompilerResults cr,
                                       ProgressMonitor monitor, string outputName)
        {
            if (!NeedsUpdate(projectFiles, configuration, outputName))
            {
                return;
            }

            string objectFiles = string.Join(" ", ObjectFiles(projectFiles, configuration, true));
            string args        = string.Format("rcs \"{0}\" {1}", outputName, objectFiles);

            monitor.BeginTask(GettextCatalog.GetString("Generating static library {0} from object files", Path.GetFileName(outputName)), 1);

            string errorOutput;
            int    exitCode = ExecuteCommand("ar", args, Path.GetDirectoryName(outputName), monitor, out errorOutput);

            if (exitCode == 0)
            {
                monitor.Step(1);
            }
            monitor.EndTask();

            ParseCompilerOutput(errorOutput, cr);
            ParseLinkerOutput(errorOutput, cr);
            CheckReturnCode(exitCode, cr);
        }
Exemplo n.º 4
0
		void GetFolderContent (Project project, string folder, out ProjectFileCollection files, out ArrayList folders)
		{
			files = new ProjectFileCollection ();
			folders = new ArrayList ();
			string folderPrefix = folder + Path.DirectorySeparatorChar;
			
			foreach (ProjectFile file in project.Files)
			{
				string dir;

				if (file.Subtype != Subtype.Directory) {
					if (file.DependsOnFile != null)
						continue;
					
					dir = file.IsLink
						? project.BaseDirectory.Combine (file.ProjectVirtualPath).ParentDirectory
						: file.FilePath.ParentDirectory;
						
					if (dir == folder) {
						files.Add (file);
						continue;
					}
				} else
					dir = file.Name;
				
				// add the directory if it isn't already present
				if (dir.StartsWith (folderPrefix)) {
					int i = dir.IndexOf (Path.DirectorySeparatorChar, folderPrefix.Length);
					if (i != -1) dir = dir.Substring (0,i);
					if (!folders.Contains (dir))
						folders.Add (dir);
				}
			}
		}
Exemplo n.º 5
0
 public FakeDotNetProject(string fileName)
     : base(fileName)
 {
     References = new ProjectReferenceCollection();
     Files      = new ProjectFileCollection();
     CreateEqualsAction();
 }
Exemplo n.º 6
0
 public FakeDotNetProject()
 {
     References             = new ProjectReferenceCollection();
     Files                  = new ProjectFileCollection();
     TargetFrameworkMoniker = new TargetFrameworkMoniker("v4.5");
     CreateEqualsAction();
 }
Exemplo n.º 7
0
		public Project ()
		{
			FileService.FileChanged += OnFileChanged;
			files = new ProjectFileCollection ();
			Items.Bind (files);
			DependencyResolutionEnabled = true;
		}
Exemplo n.º 8
0
		public FakeDotNetProject ()
		{
			References = new ProjectReferenceCollection ();
			Files = new ProjectFileCollection ();
			TargetFrameworkMoniker = new TargetFrameworkMoniker ("v4.5");
			CreateEqualsAction ();
		}
Exemplo n.º 9
0
        private void PrecompileHeaders(ProjectFileCollection projectFiles,
                                       CProjectConfiguration configuration,
                                       string args)
        {
            foreach (ProjectFile file in projectFiles)
            {
                if (file.Subtype == Subtype.Code && CProject.IsHeaderFile(file.Name))
                {
                    string precomp = Path.Combine(configuration.SourceDirectory, ".prec");
                    precomp = Path.Combine(precomp, configuration.Name);
                    precomp = Path.Combine(precomp, Path.GetFileName(file.Name) + ".ghc");

                    if (!File.Exists(precomp))
                    {
                        DoPrecompileHeader(file, precomp, args);
                        continue;
                    }

                    if (configuration.UseCcache || File.GetLastWriteTime(file.Name) > File.GetLastWriteTime(precomp))
                    {
                        DoPrecompileHeader(file, precomp, args);
                    }
                }
            }
        }
Exemplo n.º 10
0
		public FakeDotNetProject (string fileName)
			: base (fileName)
		{
			References = new ProjectReferenceCollection ();
			Files = new ProjectFileCollection ();
			CreateEqualsAction ();
		}
Exemplo n.º 11
0
		public override ICompilerResult Compile (
			ProjectFileCollection projectFiles,
		    ProjectPackageCollection packages,
		    CProjectConfiguration configuration,
		    IProgressMonitor monitor)
		{
			CompilerResults cr = new CompilerResults (new TempFileCollection ());
			bool res = true;
			string args = GetCompilerFlags (configuration);
			
			string outputName = Path.Combine (configuration.OutputDirectory,
			                                  configuration.CompiledOutputName);
			
			// Precompile header files and place them in .prec/<config_name>/
			string precdir = Path.Combine (configuration.SourceDirectory, ".prec");
			if (!Directory.Exists (precdir))
				Directory.CreateDirectory (precdir);
			precdir = Path.Combine (precdir, configuration.Name);
			if (!Directory.Exists (precdir))
				Directory.CreateDirectory (precdir);
			
			PrecompileHeaders (projectFiles, configuration, args);
			
			foreach (ProjectFile f in projectFiles) {
				if (f.Subtype == Subtype.Directory) continue;
				
				if (f.BuildAction == BuildAction.Compile) {
					if (configuration.UseCcache || NeedsCompiling (f))
						res = DoCompilation (f, args, packages, monitor, cr, configuration.UseCcache);
				}
				else
					res = true;
				
				if (!res) break;
			}

			if (res) {
				switch (configuration.CompileTarget)
				{
				case CBinding.CompileTarget.Bin:
					MakeBin (
						projectFiles, packages, configuration, cr, monitor, outputName);
					break;
				case CBinding.CompileTarget.StaticLibrary:
					MakeStaticLibrary (
						projectFiles, monitor, outputName);
					break;
				case CBinding.CompileTarget.SharedLibrary:
					MakeSharedLibrary (
						projectFiles, packages, configuration, cr, monitor, outputName);
					break;
				}
			}
			
			return new DefaultCompilerResult (cr, "");
		}
Exemplo n.º 12
0
        void GetFolderContent(Project project, string folder, out ProjectFileCollection files, out List <string> folders)
        {
            string folderPrefix = folder + Path.DirectorySeparatorChar;

            files   = new ProjectFileCollection();
            folders = new List <string> ();

            foreach (ProjectFile file in project.Files)
            {
                string dir;

                if (!file.Visible || file.Flags.HasFlag(ProjectItemFlags.Hidden))
                {
                    continue;
                }

                if (file.Subtype != Subtype.Directory)
                {
                    if (file.DependsOnFile != null)
                    {
                        continue;
                    }

                    dir = file.IsLink
                                                ? project.BaseDirectory.Combine(file.ProjectVirtualPath).ParentDirectory
                                                : file.FilePath.ParentDirectory;

                    if (dir == folder)
                    {
                        files.Add(file);
                        continue;
                    }
                }
                else
                {
                    dir = file.Name;
                }

                // add the directory if it isn't already present
                if (dir.StartsWith(folderPrefix, StringComparison.Ordinal))
                {
                    int i = dir.IndexOf(Path.DirectorySeparatorChar, folderPrefix.Length);
                    if (i != -1)
                    {
                        dir = dir.Substring(0, i);
                    }
                    if (!folders.Contains(dir))
                    {
                        folders.Add(dir);
                    }
                }
            }
        }
Exemplo n.º 13
0
        private string[] ObjectFiles(ProjectFileCollection projectFiles)
        {
            List <string> objectFiles = new List <string> ();

            foreach (ProjectFile f in projectFiles)
            {
                if (f.BuildAction == BuildAction.Compile)
                {
                    objectFiles.Add(Path.ChangeExtension(f.Name, ".o"));
                }
            }

            return(objectFiles.ToArray());
        }
        private bool NeedsUpdate(ProjectFileCollection projectFiles, CProjectConfiguration configuration, string target)
        {
            if (!File.Exists(target))
            {
                return(true);
            }

            foreach (string obj in ObjectFiles(projectFiles, configuration, false))
            {
                if (File.GetLastWriteTime(obj) > File.GetLastWriteTime(target))
                {
                    return(true);
                }
            }

            return(false);
        }
Exemplo n.º 15
0
        /// <summary>
        /// Parses a compiler output string into CompilerResults
        /// </summary>
        /// <param name="errorString">
        /// The string output by the compiler
        /// <see cref="System.String"/>
        /// </param>
        /// <param name="cr">
        /// The CompilerResults into which to parse errorString
        /// <see cref="CompilerResults"/>
        /// </param>
        protected void ParseCompilerOutput(string errorString, CompilerResults cr, ProjectFileCollection projectFiles)
        {
            TextReader reader = new StringReader(errorString);
            string     next;

            while ((next = reader.ReadLine()) != null)
            {
                CompilerError error = CreateErrorFromErrorString(next, projectFiles);
                // System.Console.WriteLine ("Creating error from string \"{0}\"", next);
                if (error != null)
                {
                    cr.Errors.Insert(0, error);
                    // System.Console.WriteLine ("Adding error");
                }
            }

            reader.Close();
        }
Exemplo n.º 16
0
        /// <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, ""));
        }
        private bool PrecompileHeaders(ProjectFileCollection projectFiles,
                                       CProjectConfiguration configuration,
                                       string args,
                                       ProgressMonitor monitor,
                                       CompilerResults cr)
        {
            monitor.BeginTask(GettextCatalog.GetString("Precompiling headers"), 1);
            bool success = true;

            foreach (ProjectFile file in projectFiles)
            {
                if (file.Subtype == Subtype.Code && CProject.IsHeaderFile(file.Name))
                {
                    string precomp = Path.Combine(configuration.IntermediateOutputDirectory, "prec");
                    precomp = Path.Combine(precomp, configuration.Id);
                    precomp = Path.Combine(precomp, Path.GetFileName(file.Name) + ".ghc");
                    if (file.BuildAction == BuildAction.Compile)
                    {
                        if (!File.Exists(precomp) || configuration.UseCcache || File.GetLastWriteTime(file.Name) > File.GetLastWriteTime(precomp))
                        {
                            if (DoPrecompileHeader(file, precomp, args, monitor, cr) == false)
                            {
                                success = false;
                                break;
                            }
                        }
                    }
                    else
                    {
                        //remove old files or they'll interfere with the build
                        if (File.Exists(precomp))
                        {
                            File.Delete(precomp);
                        }
                    }
                }
            }
            if (success)
            {
                monitor.Step(1);
            }
            monitor.EndTask();
            return(success);
        }
        public BuildResult Compile(ProjectFileCollection projectFiles, ProjectReferenceCollection projectReferences, DotNetProjectConfiguration configuration, IProgressMonitor monitor)
        {
            NemerleParameters cp = (NemerleParameters)configuration.CompilationParameters;

            if (cp == null)
            {
                cp = new NemerleParameters();
            }

            string references = "";
            string files      = "";

            foreach (ProjectReference lib in projectReferences)
            {
                foreach (string a in lib.GetReferencedFileNames())
                {
                    references += " -r \"" + a + "\"";
                }
            }

            foreach (ProjectFile f in projectFiles)
            {
                if (f.Subtype != Subtype.Directory)
                {
                    switch (f.BuildAction)
                    {
                    case BuildAction.Compile:
                        files += " \"" + f.Name + "\"";
                        break;
                    }
                }
            }

            if (!Directory.Exists(configuration.OutputDirectory))
            {
                Directory.CreateDirectory(configuration.OutputDirectory);
            }

            string args = "-q -no-color " + GetOptionsString(configuration, cp) + references + files + " -o " + configuration.CompiledOutputName;

            return(DoCompilation(args));
        }
Exemplo n.º 19
0
        private void MakeStaticLibrary(ProjectFileCollection projectFiles,
                                       IProgressMonitor monitor, string outputName)
        {
            if (!NeedsUpdate(projectFiles, outputName))
            {
                return;
            }

            string objectFiles = StringArrayToSingleString(ObjectFiles(projectFiles));

            monitor.Log.WriteLine("Generating static library...");
            monitor.Log.WriteLine("using: ar rcs " + outputName + " " + objectFiles);

            Process p = Runtime.ProcessService.StartProcess(
                "ar", "rcs " + outputName + " " + objectFiles,
                null, null);

            p.WaitForExit();
            p.Close();
        }
        public override void Clean(ProjectFileCollection projectFiles, CProjectConfiguration configuration, ProgressMonitor monitor)
        {
            //clean up object files
            foreach (string oFile in ObjectFiles(projectFiles, configuration, false))
            {
                if (File.Exists(oFile))
                {
                    File.Delete(oFile);
                }

                string dFile = Path.ChangeExtension(oFile, ".d");

                if (File.Exists(dFile))
                {
                    File.Delete(dFile);
                }
            }

            CleanPrecompiledHeaders(configuration);
        }
Exemplo n.º 21
0
        /// <summary>
        /// Creates a compiler error from an output string
        /// </summary>
        /// <param name="errorString">
        /// The error string to be parsed
        /// <see cref="System.String"/>
        /// </param>
        /// <returns>
        /// A newly created CompilerError
        /// <see cref="CompilerError"/>
        /// </returns>
        private CompilerError CreateErrorFromErrorString(string errorString, ProjectFileCollection projectFiles)
        {
            Match errorMatch = null;

            foreach (Regex regex in new Regex[] { errorRegex, gccRegex })
            {
                if ((errorMatch = regex.Match(errorString)).Success)
                {
                    break;
                }
            }

            if (!errorMatch.Success)
            {
                return(null);
            }

            CompilerError error = new CompilerError();

            foreach (ProjectFile pf in projectFiles)
            {
                if (Path.GetFileName(pf.Name) == errorMatch.Groups["file"].Value)
                {
                    error.FileName = pf.FilePath;
                    break;
                }
            }            // check for fully pathed file
            if (string.Empty == error.FileName)
            {
                error.FileName = errorMatch.Groups["file"].Value;
            }            // fallback to exact match
            error.Line = int.Parse(errorMatch.Groups["line"].Value);
            if (errorMatch.Groups["column"].Success)
            {
                error.Column = int.Parse(errorMatch.Groups["column"].Value);
            }
            error.IsWarning = !errorMatch.Groups["level"].Value.Equals(GettextCatalog.GetString("error"), StringComparison.Ordinal);
            error.ErrorText = errorMatch.Groups["message"].Value;

            return(error);
        }
Exemplo n.º 22
0
        /// <summary>
        /// Compiles the project
        /// </summary>
        private bool DoCompilation(ProjectFileCollection projectFiles, string args,
                                   string outputName,
                                   IProgressMonitor monitor,
                                   CompilerResults cr)
        {
            StringBuilder filelist = new StringBuilder();

            foreach (ProjectFile f in projectFiles)
            {
                if (f.Subtype != Subtype.Directory && f.BuildAction == BuildAction.Compile)
                {
                    filelist.AppendFormat("\"{0}\" ", f.FilePath);
                }
            }            /// Build file list

            string compiler_args = string.Format("{0} {1} -o \"{2}\"",
                                                 args, filelist.ToString(), Path.GetFileName(outputName));

            string errorOutput = string.Empty;
            int    exitCode    = ExecuteCommand(compilerCommand, compiler_args, Path.GetDirectoryName(outputName), monitor, out errorOutput);

            ParseCompilerOutput(errorOutput, cr, projectFiles);
            return(exitCode == 0);
        }
Exemplo n.º 23
0
		/// <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); }
		}
Exemplo n.º 24
0
		public abstract BuildResult Compile (
		    Project project,
		    ProjectFileCollection projectFiles,
		    ProjectPackageCollection packages,
		    CProjectConfiguration configuration,
		    IProgressMonitor monitor);
Exemplo n.º 25
0
		private bool NeedsUpdate (ProjectFileCollection projectFiles, CProjectConfiguration configuration, string target)
		{
			if (!File.Exists (target))
				return true;
			
			foreach (string obj in ObjectFiles (projectFiles, configuration, false))
				if (File.GetLastWriteTime (obj) > File.GetLastWriteTime (target))
					return true;
			
			return false;
		}
Exemplo n.º 26
0
		/// <summary>
		/// Gets the files that get compiled into object code.
		/// </summary>
		/// <param name="projectFiles">
		/// A <see cref="ProjectFileCollection"/>
		/// The project's files, extracts from here the files that get compiled into object code.
		/// </param>
		/// <param name="configuration">
		/// A <see cref="CProjectConfiguration"/>
		/// The configuration to get the object files for...
		/// </param>
		/// <param name="withQuotes">
		/// A <see cref="System.Boolean"/>
		/// If true, it will surround each object file with quotes 
		/// so that gcc has no problem with paths that contain spaces.
		/// </param>
		/// <returns>
		/// An array of strings, each string is the name of a file
		/// that will get compiled into object code. The file name
		/// will already have the .o extension.
		/// </returns>
		private string[] ObjectFiles (ProjectFileCollection projectFiles, CProjectConfiguration configuration, bool withQuotes)
		{
			if(projectFiles.Count == 0)
				return new string[] {};

			List<string> objectFiles = new List<string> ();
			
			foreach (ProjectFile f in projectFiles) {
				if (f.BuildAction == BuildAction.Compile) {
					string PathName = Path.Combine(configuration.OutputDirectory, Path.GetFileNameWithoutExtension(f.Name) + ".o");

					if(File.Exists(PathName) == false)
						continue;
					
					if (!withQuotes)
						objectFiles.Add (PathName);
					else
						objectFiles.Add ("\"" + PathName + "\"");
				}
			}
			
			return objectFiles.ToArray ();
		}
Exemplo n.º 27
0
		private void MakeSharedLibrary(Project project,
		                               ProjectFileCollection projectFiles,
		                               CProjectConfiguration configuration,
		                               ProjectPackageCollection packages,
		                               CompilerResults cr,
		                               IProgressMonitor monitor, string outputName)
		{
			if (!NeedsUpdate (projectFiles, configuration, outputName)) return;
			
			string objectFiles = string.Join (" ", ObjectFiles (projectFiles, configuration, true));
			string pkgargs = GeneratePkgLinkerArgs (packages);
			StringBuilder args = new StringBuilder ();
			
			if (configuration.ExtraLinkerArguments != null && configuration.ExtraLinkerArguments.Length > 0) {
				string extraLinkerArgs = ExpandBacktickedParameters(configuration.ExtraLinkerArguments.Replace ('\n', ' '));
				args.Append (extraLinkerArgs + " ");
			}
			
			if (configuration.LibPaths != null)
				foreach (string libpath in configuration.LibPaths)
					args.Append ("-L\"" + StringParserService.Parse (libpath, GetStringTags (project)) + "\" ");
			
			if (configuration.Libs != null) {
				foreach (string lib in configuration.Libs) {
					string directory = Path.GetDirectoryName(lib);
					string library = Path.GetFileName(lib);

					// Is this a 'standard' (as in, uses an orthodox naming convention) library..?
					string link_lib = String.Empty;
					if(IsStandardLibrary(configuration, directory, library, ref link_lib))
						args.Append ("-l\"" + link_lib + "\" ");
					// If not, reference the library by it's full pathname.
					else
						args.Append ("\"" + lib + "\" ");
				}
			}
			
			string linker_args = string.Format ("-shared -o \"{0}\" {1} {2} {3}",
			    outputName, pkgargs, objectFiles, args.ToString ());
			
			monitor.BeginTask (GettextCatalog.GetString ("Generating shared object \"{0}\" from object files", Path.GetFileName (outputName)), 1);
			
			string errorOutput;
			int exitCode = ExecuteCommand (linkerCommand , linker_args, Path.GetDirectoryName (outputName), monitor, out errorOutput);
			if (exitCode == 0)
				monitor.Step (1);
			monitor.EndTask ();
			
			ParseCompilerOutput (errorOutput, cr);
			ParseLinkerOutput (errorOutput, cr);
			CheckReturnCode (exitCode, cr);
		}
Exemplo n.º 28
0
		private bool PrecompileHeaders (ProjectFileCollection projectFiles,
		                                CProjectConfiguration configuration,
		                                string args,
		                                IProgressMonitor monitor,
		                                CompilerResults cr)
		{
			monitor.BeginTask (GettextCatalog.GetString ("Precompiling headers"), 1);
			bool success = true;
			
			foreach (ProjectFile file in projectFiles) {
				if (file.Subtype == Subtype.Code && CProject.IsHeaderFile (file.Name)) {
					string precomp = Path.Combine (configuration.SourceDirectory, ".prec");
					precomp = Path.Combine (precomp, configuration.Id);
					precomp = Path.Combine (precomp, Path.GetFileName (file.Name) + ".ghc");
					if (file.BuildAction == BuildAction.Compile) {
						if (!File.Exists (precomp) || configuration.UseCcache || File.GetLastWriteTime (file.Name) > File.GetLastWriteTime (precomp)) {
							if (DoPrecompileHeader (file, precomp, args, monitor, cr) == false) {
								success = false;
								break;
							}
						}
					} else {
						//remove old files or they'll interfere with the build
						if (File.Exists (precomp))
							File.Delete (precomp);
					}
				}
				
			}
			if (success)
				monitor.Step (1);
			monitor.EndTask ();
			return success;
		}
Exemplo n.º 29
0
		/// <summary>
		/// Parses a compiler output string into CompilerResults
		/// </summary>
		/// <param name="errorString">
		/// The string output by the compiler
		/// <see cref="System.String"/>
		/// </param>
		/// <param name="cr">
		/// The CompilerResults into which to parse errorString
		/// <see cref="CompilerResults"/>
		/// </param>
		protected void ParseCompilerOutput (string errorString, CompilerResults cr, ProjectFileCollection projectFiles)
		{
			TextReader reader = new StringReader (errorString);
			string next;
				
			while ((next = reader.ReadLine ()) != null) {
				CompilerError error = CreateErrorFromErrorString (next, projectFiles);
				// System.Console.WriteLine ("Creating error from string \"{0}\"", next);
				if (error != null) {
					cr.Errors.Insert (0, error);
					// System.Console.WriteLine ("Adding error");
				}
			}
			
			reader.Close ();
		}
Exemplo n.º 30
0
		public BuildResult Compile (ProjectFileCollection projectFiles, ProjectReferenceCollection references, DotNetProjectConfiguration configuration, IProgressMonitor monitor)
		{
			return compilerServices.Compile (projectFiles, references, configuration, monitor);
		}
Exemplo n.º 31
0
		/// <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, "");
		}
Exemplo n.º 32
0
 public abstract BuildResult Compile(
     Project project,
     ProjectFileCollection projectFiles,
     ProjectPackageCollection packages,
     CProjectConfiguration configuration,
     IProgressMonitor monitor);
Exemplo n.º 33
0
 /// <summary>
 /// Determines whether the target needs to be updated
 /// </summary>
 /// <param name="projectFiles">
 /// The project's files
 /// <see cref="ProjectFileCollection"/>
 /// </param>
 /// <param name="target">
 /// The target
 /// <see cref="System.String"/>
 /// </param>
 /// <returns>
 /// true if target needs to be updated
 /// <see cref="System.Boolean"/>
 /// </returns>
 private bool NeedsUpdate(ProjectFileCollection projectFiles,
                          string target)
 {
     return(true);
 }
Exemplo n.º 34
0
		private void MakeSharedLibrary(ProjectFileCollection projectFiles,
		                               ProjectPackageCollection packages,
		                               CProjectConfiguration configuration,
		                               CompilerResults cr,
		                               IProgressMonitor monitor, string outputName)
		{
			if (!NeedsUpdate (projectFiles, outputName)) return;
			
			string objectFiles = StringArrayToSingleString (ObjectFiles (projectFiles));
			string pkgargs = GeneratePkgLinkerArgs (packages);
			StringBuilder args = new StringBuilder ();
			CCompilationParameters cp =
				(CCompilationParameters)configuration.CompilationParameters;
			
			if (cp.ExtraLinkerArguments != null && cp.ExtraLinkerArguments.Length > 0) {
				string extraLinkerArgs = cp.ExtraLinkerArguments.Replace ('\n', ' ');
				args.Append (extraLinkerArgs + " ");
			}
			
			if (configuration.LibPaths != null)
				foreach (string libpath in configuration.LibPaths)
					args.Append ("-L" + libpath + " ");
			
			if (configuration.Libs != null)
				foreach (string lib in configuration.Libs)
					args.Append ("-l" + lib + " ");
			
			monitor.Log.WriteLine ("Generating shared object...");
			
			string linker_args = string.Format ("-shared -o {0} {1} {2} {3}",
			    outputName, objectFiles, args.ToString (), pkgargs);
			
			monitor.Log.WriteLine ("using: " + linkerCommand + " " + linker_args);
			
			ProcessWrapper p = Runtime.ProcessService.StartProcess (linkerCommand, linker_args, null, null);

			p.WaitForExit ();
			
			string line;
			StringWriter error = new StringWriter ();
			
			while ((line = p.StandardError.ReadLine ()) != null)
				error.WriteLine (line);
			
			monitor.Log.WriteLine (error.ToString ());
			
			ParseCompilerOutput (error.ToString (), cr);
			
			error.Close ();
			p.Close ();
			
			ParseLinkerOutput (error.ToString (), cr);
		}
Exemplo n.º 35
0
		private string[] ObjectFiles (ProjectFileCollection projectFiles)
		{
			List<string> objectFiles = new List<string> ();
			
			foreach (ProjectFile f in projectFiles) {
				if (f.BuildAction == BuildAction.Compile) {
					objectFiles.Add (Path.ChangeExtension (f.Name, ".o"));
				}
			}
			
			return objectFiles.ToArray ();
		}
Exemplo n.º 36
0
		/// <summary>
		/// Compiles the project
		/// </summary>
		private bool DoCompilation (ProjectFileCollection projectFiles, string args,
									string outputName,
									IProgressMonitor monitor,
									CompilerResults cr)
		{
			StringBuilder filelist = new StringBuilder ();
			foreach (ProjectFile f in projectFiles) { 
				if (f.Subtype != Subtype.Directory && f.BuildAction == BuildAction.Compile) {
					filelist.AppendFormat ("\"{0}\" ", f.FilePath);
				}
			}/// Build file list

			string compiler_args = string.Format ("{0} {1} -o \"{2}\"",
				args, filelist.ToString (), Path.GetFileName (outputName));
			
			string errorOutput = string.Empty;
			int exitCode = ExecuteCommand (compilerCommand, compiler_args, Path.GetDirectoryName (outputName), monitor, out errorOutput);
			
			ParseCompilerOutput (errorOutput, cr, projectFiles);
			return exitCode == 0;
		}
Exemplo n.º 37
0
        public override ICompilerResult Compile(
            ProjectFileCollection projectFiles,
            ProjectPackageCollection packages,
            CProjectConfiguration configuration,
            IProgressMonitor monitor)
        {
            CompilerResults cr   = new CompilerResults(new TempFileCollection());
            bool            res  = true;
            string          args = GetCompilerFlags(configuration);

            string outputName = Path.Combine(configuration.OutputDirectory,
                                             configuration.CompiledOutputName);

            // Precompile header files and place them in .prec/<config_name>/
            string precdir = Path.Combine(configuration.SourceDirectory, ".prec");

            if (!Directory.Exists(precdir))
            {
                Directory.CreateDirectory(precdir);
            }
            precdir = Path.Combine(precdir, configuration.Name);
            if (!Directory.Exists(precdir))
            {
                Directory.CreateDirectory(precdir);
            }

            PrecompileHeaders(projectFiles, configuration, args);

            foreach (ProjectFile f in projectFiles)
            {
                if (f.Subtype == Subtype.Directory)
                {
                    continue;
                }

                if (f.BuildAction == BuildAction.Compile)
                {
                    if (configuration.UseCcache || NeedsCompiling(f))
                    {
                        res = DoCompilation(f, args, packages, monitor, cr, configuration.UseCcache);
                    }
                }
                else
                {
                    res = true;
                }

                if (!res)
                {
                    break;
                }
            }

            if (res)
            {
                switch (configuration.CompileTarget)
                {
                case CBinding.CompileTarget.Bin:
                    MakeBin(
                        projectFiles, packages, configuration, cr, monitor, outputName);
                    break;

                case CBinding.CompileTarget.StaticLibrary:
                    MakeStaticLibrary(
                        projectFiles, monitor, outputName);
                    break;

                case CBinding.CompileTarget.SharedLibrary:
                    MakeSharedLibrary(
                        projectFiles, packages, configuration, cr, monitor, outputName);
                    break;
                }
            }

            return(new DefaultCompilerResult(cr, ""));
        }
Exemplo n.º 38
0
        /// <summary>
        /// Compiles a D project.
        /// </summary>
        public static BuildResult Compile(
            DProject Project,
            ProjectFileCollection FilesToCompile,
            DProjectConfiguration BuildConfig,
            IProgressMonitor monitor)
        {
            var relObjDir = "objs";
            var objDir    = Path.Combine(Project.BaseDirectory, relObjDir);

            if (!Directory.Exists(objDir))
            {
                Directory.CreateDirectory(objDir);
            }

            // List of created object files
            var  BuiltObjects      = new List <string>();
            var  compilerResults   = new CompilerResults(new TempFileCollection());
            var  buildResult       = new BuildResult(compilerResults, "");
            bool succesfullyBuilt  = true;
            bool modificationsDone = false;

            var Compiler  = Project.Compiler;
            var Commands  = Compiler.GetTargetConfiguration(Project.CompileTarget);
            var Arguments = Commands.GetArguments(BuildConfig.DebugMode);

            /// The target file to which all objects will be linked to
            var LinkTarget = BuildConfig.OutputDirectory.Combine(BuildConfig.CompiledOutputName);

            monitor.BeginTask("Build Project", FilesToCompile.Count + 1);

            var SourceIncludePaths = new List <string>(Compiler.GlobalParseCache.DirectoryPaths);

            SourceIncludePaths.AddRange(Project.LocalIncludeCache.DirectoryPaths);

            #region Compile sources to objects
            foreach (var f in FilesToCompile)
            {
                if (monitor.IsCancelRequested)
                {
                    return(buildResult);
                }

                // If not compilable, skip it
                if (f.BuildAction != BuildAction.Compile || !File.Exists(f.FilePath))
                {
                    continue;
                }

                // a.Check if source file was modified and if object file still exists
                if (Project.LastModificationTimes.ContainsKey(f) &&
                    Project.LastModificationTimes[f] == File.GetLastWriteTime(f.FilePath) &&
                    File.Exists(f.LastGenOutput))
                {
                    // File wasn't edited since last build
                    // but add the built object to the objs array
                    BuiltObjects.Add(f.LastGenOutput);
                    monitor.Step(1);
                    continue;
                }
                else
                {
                    modificationsDone = true;
                }

                #region Resource file
                if (f.Name.EndsWith(".rc", StringComparison.OrdinalIgnoreCase))
                {
                    var res = Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath)) + ".res";

                    if (File.Exists(res))
                    {
                        File.Delete(res);
                    }

                    // Build argument string
                    var resCmpArgs = FillInMacros(Win32ResourceCompiler.Instance.Arguments,
                                                  new Win32ResourceCompiler.ArgProvider {
                        RcFile  = f.FilePath.ToString(),
                        ResFile = res
                    });

                    // Execute compiler
                    string output;
                    int    _exitCode = ExecuteCommand(Win32ResourceCompiler.Instance.Executable,
                                                      resCmpArgs,
                                                      Project.BaseDirectory,
                                                      monitor,
                                                      out output);

                    // Error analysis
                    if (!string.IsNullOrEmpty(output))
                    {
                        compilerResults.Errors.Add(new CompilerError {
                            FileName = f.FilePath, ErrorText = output
                        });
                    }
                    CheckReturnCode(_exitCode, compilerResults);

                    monitor.Step(1);

                    if (_exitCode != 0)
                    {
                        buildResult.FailedBuildCount++;
                        succesfullyBuilt = false;
                        break;
                    }
                    else
                    {
                        f.LastGenOutput = res;
                        buildResult.BuildCount++;
                        Project.LastModificationTimes[f] = File.GetLastWriteTime(f.FilePath);

                        // Especially when compiling large projects, do only add the relative part of the r file due to command shortness
                        if (res.StartsWith(Project.BaseDirectory))
                        {
                            BuiltObjects.Add(res.Substring(Project.BaseDirectory.ToString().Length).TrimStart(Path.DirectorySeparatorChar));
                        }
                        else
                        {
                            BuiltObjects.Add(res);
                        }
                    }

                    continue;
                }
                #endregion

                // Create object file path
                var obj = Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath)) + ObjectExtension;

                if (File.Exists(obj))
                {
                    File.Delete(obj);
                }

                // Prevent duplicates e.g. when having the samely-named source files in different sub-packages
                int i = 2;
                while (File.Exists(obj))
                {
                    // Simply add a number between the obj name and its extension
                    obj = Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath)) + i + ObjectExtension;
                    i++;
                }

                // Create argument string for source file compilation.
                var dmdArgs = FillInMacros(Arguments.CompilerArguments + " " + BuildConfig.ExtraCompilerArguments, new DCompilerMacroProvider
                {
                    IncludePathConcatPattern = Commands.IncludePathPattern,
                    SourceFile = f.FilePath,
                    ObjectFile = obj,
                    Includes   = SourceIncludePaths,
                });

                // b.Execute compiler
                string dmdOutput;
                int    exitCode = ExecuteCommand(Commands.Compiler, dmdArgs, Project.BaseDirectory, monitor, out dmdOutput);

                ParseCompilerOutput(dmdOutput, compilerResults);
                CheckReturnCode(exitCode, compilerResults);

                monitor.Step(1);

                if (exitCode != 0)
                {
                    buildResult.FailedBuildCount++;
                    succesfullyBuilt = false;
                    break;
                }
                else
                {
                    f.LastGenOutput = obj;
                    buildResult.BuildCount++;
                    Project.LastModificationTimes[f] = File.GetLastWriteTime(f.FilePath);

                    // Especially when compiling large projects, do only add the relative part of the obj file due to command shortness
                    if (obj.StartsWith(Project.BaseDirectory))
                    {
                        BuiltObjects.Add(obj.Substring(Project.BaseDirectory.ToString().Length).TrimStart(Path.DirectorySeparatorChar));
                    }
                    else
                    {
                        BuiltObjects.Add(obj);
                    }
                }
            }
            #endregion

            #region Link files
            if (succesfullyBuilt)
            {
                // a.
                if ((!modificationsDone) && lastLinkerActionSuccessfull)
                {
                    // Only return if build target is still existing
                    if (File.Exists(LinkTarget))
                    {
                        monitor.Step(1);
                        return(new BuildResult(compilerResults, ""));
                    }
                }

                // b.Build linker argument string

                // Build argument preparation

                /*
                 * var libPaths=new List<string>(Compiler.DefaultLibPaths);
                 * libPaths.AddRange(Project.LibraryPaths);
                 */
                var libs = new List <string>(Compiler.DefaultLibraries);
                libs.AddRange(Project.ExtraLibraries);

                var linkArgs = FillInMacros(Arguments.LinkerArguments + " " + BuildConfig.ExtraLinkerArguments,
                                            new DLinkerMacroProvider {
                    ObjectsStringPattern = Commands.ObjectFileLinkPattern,
                    Objects    = BuiltObjects.ToArray(),
                    TargetFile = LinkTarget,
                    RelativeTargetDirectory = BuildConfig.OutputDirectory.ToRelative(Project.BaseDirectory),

                    //LibraryPaths=libPaths,
                    Libraries = libs
                });
                var linkerOutput = "";
                int exitCode     = ExecuteCommand(Commands.Linker, linkArgs, Project.BaseDirectory, monitor, out linkerOutput);

                compilerResults.NativeCompilerReturnValue = exitCode;

                CheckReturnCode(exitCode, compilerResults);

                lastLinkerActionSuccessfull = (exitCode == 0);
                if (lastLinkerActionSuccessfull)
                {
                    monitor.ReportSuccess("Build successful!");
                    monitor.Step(1);
                }
            }
            #endregion

            return(new BuildResult(compilerResults, ""));
        }
Exemplo n.º 39
0
		private void MakeStaticLibrary (ProjectFileCollection projectFiles,
		                                IProgressMonitor monitor, string outputName)
		{
			if (!NeedsUpdate (projectFiles, outputName)) return;
			
			string objectFiles = StringArrayToSingleString (ObjectFiles (projectFiles));
			
			monitor.Log.WriteLine ("Generating static library...");
			monitor.Log.WriteLine ("using: ar rcs " + outputName + " " + objectFiles);
			
			Process p = Runtime.ProcessService.StartProcess (
				"ar", "rcs " + outputName + " " + objectFiles,
				null, null);
			p.WaitForExit ();
			p.Close ();
		}
Exemplo n.º 40
0
        protected void GetContents(MonoDevelop.Projects.Project project, MonoDevelop.Prj2Make.Schema.Csproj.File[] Include, ProjectFileCollection files, IProgressMonitor monitor)
        {
            if (Include == null || Include.Length == 0)
            {
                return;
            }

            // Iterate through the file collection of the csproj file
            foreach (MonoDevelop.Prj2Make.Schema.Csproj.File fl in Include)
            {
                ProjectFile flOut = new ProjectFile();

                string name;
                if ((fl.Link == null) || (fl.Link.Length == 0))
                {
                    name = MapPath(project.BaseDirectory, fl.RelPath);
                }
                else
                {
                    name = MapPath(null, fl.Link);
                }

                if (name == null)
                {
                    monitor.ReportWarning(GettextCatalog.GetString("Can't import file: ") + fl.RelPath);
                    continue;
                }
                flOut.Name = name;
                // Adding here as GetDefaultResourceIdInternal needs flOut.Project
                files.Add(flOut);

                switch (fl.SubType)
                {
                case "Code":
                    flOut.Subtype = Subtype.Code;
                    break;
                }

                switch (fl.BuildAction)
                {
                case MonoDevelop.Prj2Make.Schema.Csproj.FileBuildAction.Compile:
                    flOut.BuildAction = BuildAction.Compile;
                    break;

                case MonoDevelop.Prj2Make.Schema.Csproj.FileBuildAction.Content:
                    flOut.BuildAction = BuildAction.Content;
                    break;

                case MonoDevelop.Prj2Make.Schema.Csproj.FileBuildAction.EmbeddedResource:
                    flOut.BuildAction = BuildAction.EmbeddedResource;
                    break;

                case MonoDevelop.Prj2Make.Schema.Csproj.FileBuildAction.None:
                    flOut.BuildAction = BuildAction.None;
                    break;
                }
                // DependentUpon is relative to flOut
                flOut.DependsOn = MapPath(Path.GetDirectoryName(flOut.Name), fl.DependentUpon);
                flOut.Data      = "";
            }
        }
        private void MakeSharedLibrary(Project project,
                                       ProjectFileCollection projectFiles,
                                       CProjectConfiguration configuration,
                                       ProjectPackageCollection packages,
                                       CompilerResults cr,
                                       ProgressMonitor monitor, string outputName)
        {
            if (!NeedsUpdate(projectFiles, configuration, outputName))
            {
                return;
            }

            string        objectFiles = string.Join(" ", ObjectFiles(projectFiles, configuration, true));
            string        pkgargs     = GeneratePkgLinkerArgs(packages);
            StringBuilder args        = new StringBuilder();

            if (configuration.ExtraLinkerArguments != null && configuration.ExtraLinkerArguments.Length > 0)
            {
                string extraLinkerArgs = ExpandBacktickedParameters(configuration.ExtraLinkerArguments.Replace('\n', ' '));
                args.Append(extraLinkerArgs + " ");
            }

            if (configuration.LibPaths != null)
            {
                foreach (string libpath in configuration.LibPaths)
                {
                    args.Append("-L\"" + StringParserService.Parse(libpath, GetStringTags(project)) + "\" ");
                }
            }

            if (configuration.Libs != null)
            {
                foreach (string lib in configuration.Libs)
                {
                    string directory = Path.GetDirectoryName(lib);
                    string library   = Path.GetFileName(lib);

                    // Is this a 'standard' (as in, uses an orthodox naming convention) library..?
                    string link_lib = String.Empty;
                    if (IsStandardLibrary(configuration, directory, library, ref link_lib))
                    {
                        args.Append("-l\"" + link_lib + "\" ");
                    }
                    // If not, reference the library by it's full pathname.
                    else
                    {
                        args.Append("\"" + lib + "\" ");
                    }
                }
            }

            string linker_args = string.Format("-shared -o \"{0}\" {1} {2} {3}",
                                               outputName, objectFiles, pkgargs, args.ToString());

            monitor.BeginTask(GettextCatalog.GetString("Generating shared object \"{0}\" from object files", Path.GetFileName(outputName)), 1);

            string errorOutput;
            int    exitCode = ExecuteCommand(linkerCommand, linker_args, Path.GetDirectoryName(outputName), monitor, out errorOutput);

            if (exitCode == 0)
            {
                monitor.Step(1);
            }
            monitor.EndTask();

            ParseCompilerOutput(errorOutput, cr);
            ParseLinkerOutput(errorOutput, cr);
            CheckReturnCode(exitCode, cr);
        }
Exemplo n.º 42
0
		private void MakeStaticLibrary (Project project,
		                                ProjectFileCollection projectFiles,
		                                CProjectConfiguration configuration,
		                                ProjectPackageCollection packages,
		                                CompilerResults cr,
		                                IProgressMonitor monitor, string outputName)
		{
			if (!NeedsUpdate (projectFiles, configuration, outputName)) return;
			
			string objectFiles = string.Join (" ", ObjectFiles (projectFiles, configuration, true));
			string args = string.Format ("rcs \"{0}\" {1}", outputName, objectFiles);
			
			monitor.BeginTask (GettextCatalog.GetString ("Generating static library {0} from object files", Path.GetFileName (outputName)), 1);
			
			string errorOutput;
			int exitCode = ExecuteCommand ("ar", args, Path.GetDirectoryName (outputName), monitor, out errorOutput);
			if (exitCode == 0)
				monitor.Step (1);
			monitor.EndTask ();
			
			ParseCompilerOutput (errorOutput, cr);
			ParseLinkerOutput (errorOutput, cr);
			CheckReturnCode (exitCode, cr);
		}
        public override BuildResult Compile(
            Project project,
            ProjectFileCollection projectFiles,
            ProjectPackageCollection packages,
            CProjectConfiguration configuration,
            ProgressMonitor monitor)
        {
            if (!appsChecked)
            {
                appsChecked   = true;
                compilerFound = CheckApp(compilerCommand);
                linkerFound   = CheckApp(linkerCommand);
            }

            if (!compilerFound)
            {
                BuildResult cres = new BuildResult();
                cres.AddError("Compiler not found: " + compilerCommand);
                return(cres);
            }

            if (!linkerFound)
            {
                BuildResult cres = new BuildResult();
                cres.AddError("Linker not found: " + linkerCommand);
                return(cres);
            }

            CompilerResults cr           = new CompilerResults(new TempFileCollection());
            bool            success      = true;
            string          compilerArgs = GetCompilerFlags(project, configuration) + " " + GeneratePkgCompilerArgs(packages);

            string outputName = Path.Combine(configuration.OutputDirectory,
                                             configuration.CompiledOutputName);

            // Precompile header files and place them in prec/<config_name>/
            if (configuration.PrecompileHeaders)
            {
                string precDir       = Path.Combine(configuration.IntermediateOutputDirectory, "prec");
                string precConfigDir = Path.Combine(precDir, configuration.Id);
                if (!Directory.Exists(precDir))
                {
                    Directory.CreateDirectory(precDir);
                }
                if (!Directory.Exists(precConfigDir))
                {
                    Directory.CreateDirectory(precConfigDir);
                }

                if (!PrecompileHeaders(projectFiles, configuration, compilerArgs, monitor, cr))
                {
                    success = false;
                }
            }
            else
            {
                //old headers could interfere with the build
                CleanPrecompiledHeaders(configuration);
            }

            //compile source to object files
            monitor.BeginTask(GettextCatalog.GetString("Compiling source to object files"), 1);
            foreach (ProjectFile f in projectFiles)
            {
                if (!success)
                {
                    break;
                }
                if (f.Subtype == Subtype.Directory || f.BuildAction != BuildAction.Compile || CProject.IsHeaderFile(f.FilePath))
                {
                    continue;
                }

                if (configuration.UseCcache || NeedsCompiling(f, configuration))
                {
                    success = DoCompilation(f, configuration, compilerArgs, monitor, cr, configuration.UseCcache);
                }
            }
            if (success)
            {
                monitor.Step(1);
            }
            monitor.EndTask();

            if (success)
            {
                switch (configuration.CompileTarget)
                {
                case CBinding.CompileTarget.Bin:
                    MakeBin(project, projectFiles, configuration, packages, cr, monitor, outputName);
                    break;

                case CBinding.CompileTarget.StaticLibrary:
                    MakeStaticLibrary(project, projectFiles, configuration, packages, cr, monitor, outputName);
                    break;

                case CBinding.CompileTarget.SharedLibrary:
                    MakeSharedLibrary(project, projectFiles, configuration, packages, cr, monitor, outputName);
                    break;
                }
            }

            return(new BuildResult(cr, ""));
        }
Exemplo n.º 44
0
		public override BuildResult Compile (
		    Project project,
		    ProjectFileCollection projectFiles,
		    ProjectPackageCollection packages,
		    CProjectConfiguration configuration,
		    IProgressMonitor monitor)
		{
			if (!appsChecked) {
				appsChecked = true;
				compilerFound = CheckApp (compilerCommand);
				linkerFound = CheckApp (linkerCommand);
			}
				
			if (!compilerFound) {
				BuildResult cres = new BuildResult ();
				cres.AddError ("Compiler not found: " + compilerCommand);
				return cres;
			}
			
			if (!linkerFound) {
				BuildResult cres = new BuildResult ();
				cres.AddError ("Linker not found: " + linkerCommand);
				return cres;
			}
			
			CompilerResults cr = new CompilerResults (new TempFileCollection ());
			bool success = true;
			string compilerArgs = GetCompilerFlags (project, configuration) + " " + GeneratePkgCompilerArgs (packages);
			
			string outputName = Path.Combine (configuration.OutputDirectory,
			                                  configuration.CompiledOutputName);
			
			// Precompile header files and place them in .prec/<config_name>/
			if (configuration.PrecompileHeaders) {
				string precDir = Path.Combine (configuration.SourceDirectory, ".prec");
				string precConfigDir = Path.Combine (precDir, configuration.Id);
				if (!Directory.Exists (precDir))
					Directory.CreateDirectory (precDir);
				if (!Directory.Exists (precConfigDir))
					Directory.CreateDirectory (precConfigDir);
				
				if (!PrecompileHeaders (projectFiles, configuration, compilerArgs, monitor, cr))
					success = false;
			} else {
				//old headers could interfere with the build
				CleanPrecompiledHeaders (configuration);
			}
			
			//compile source to object files
			monitor.BeginTask (GettextCatalog.GetString ("Compiling source to object files"), 1);
			foreach (ProjectFile f in projectFiles) {
				if (!success) break;
				if (f.Subtype == Subtype.Directory || f.BuildAction != BuildAction.Compile || CProject.IsHeaderFile (f.FilePath))
					continue;
				
				if (configuration.UseCcache || NeedsCompiling (f, configuration))
					success = DoCompilation (f, configuration, compilerArgs, monitor, cr, configuration.UseCcache);
			}
			if (success)
				monitor.Step (1);
			monitor.EndTask ();

			if (success) {
				switch (configuration.CompileTarget)
				{
				case CBinding.CompileTarget.Bin:
					MakeBin (project, projectFiles, configuration, packages, cr, monitor, outputName);
					break;
				case CBinding.CompileTarget.StaticLibrary:
					MakeStaticLibrary (project, projectFiles, configuration, packages, cr, monitor, outputName);
					break;
				case CBinding.CompileTarget.SharedLibrary:
					MakeSharedLibrary (project, projectFiles, configuration, packages, cr, monitor, outputName);
					break;
				}
			}
			
			return new BuildResult (cr, "");
		}
Exemplo n.º 45
0
		private void PrecompileHeaders (ProjectFileCollection projectFiles,
		                                CProjectConfiguration configuration,
		                                string args)
		{
			foreach (ProjectFile file in projectFiles) {
				if (file.Subtype == Subtype.Code && CProject.IsHeaderFile (file.Name)) {
					string precomp = Path.Combine (configuration.SourceDirectory, ".prec");
					precomp = Path.Combine (precomp, configuration.Name);
					precomp = Path.Combine (precomp, Path.GetFileName (file.Name) + ".ghc");
					
					if (!File.Exists (precomp)) {
						DoPrecompileHeader (file, precomp, args);
						continue;
					}
					
					if (configuration.UseCcache || File.GetLastWriteTime (file.Name) > File.GetLastWriteTime (precomp)) {
						DoPrecompileHeader (file, precomp, args);
					}
				}
			}
		}
Exemplo n.º 46
0
		public override void Clean (ProjectFileCollection projectFiles, CProjectConfiguration configuration, IProgressMonitor monitor)
		{
			//clean up object files
			foreach (string oFile in ObjectFiles(projectFiles, configuration, false)) {
				if (File.Exists (oFile))
					File.Delete (oFile);
				
				string dFile = Path.ChangeExtension (oFile, ".d");
				if (File.Exists (dFile))
					File.Delete (dFile);
			}
			
			CleanPrecompiledHeaders (configuration);
		}
Exemplo n.º 47
0
        private void MakeSharedLibrary(ProjectFileCollection projectFiles,
                                       ProjectPackageCollection packages,
                                       CProjectConfiguration configuration,
                                       CompilerResults cr,
                                       IProgressMonitor monitor, string outputName)
        {
            if (!NeedsUpdate(projectFiles, outputName))
            {
                return;
            }

            string                 objectFiles = StringArrayToSingleString(ObjectFiles(projectFiles));
            string                 pkgargs     = GeneratePkgLinkerArgs(packages);
            StringBuilder          args        = new StringBuilder();
            CCompilationParameters cp          =
                (CCompilationParameters)configuration.CompilationParameters;

            if (cp.ExtraLinkerArguments != null && cp.ExtraLinkerArguments.Length > 0)
            {
                string extraLinkerArgs = cp.ExtraLinkerArguments.Replace('\n', ' ');
                args.Append(extraLinkerArgs + " ");
            }

            if (configuration.LibPaths != null)
            {
                foreach (string libpath in configuration.LibPaths)
                {
                    args.Append("-L" + libpath + " ");
                }
            }

            if (configuration.Libs != null)
            {
                foreach (string lib in configuration.Libs)
                {
                    args.Append("-l" + lib + " ");
                }
            }

            monitor.Log.WriteLine("Generating shared object...");

            string linker_args = string.Format("-shared -o {0} {1} {2} {3}",
                                               outputName, objectFiles, args.ToString(), pkgargs);

            monitor.Log.WriteLine("using: " + linkerCommand + " " + linker_args);

            ProcessWrapper p = Runtime.ProcessService.StartProcess(linkerCommand, linker_args, null, null);

            p.WaitForExit();

            string       line;
            StringWriter error = new StringWriter();

            while ((line = p.StandardError.ReadLine()) != null)
            {
                error.WriteLine(line);
            }

            monitor.Log.WriteLine(error.ToString());

            ParseCompilerOutput(error.ToString(), cr);

            error.Close();
            p.Close();

            ParseLinkerOutput(error.ToString(), cr);
        }
Exemplo n.º 48
0
		/// <summary>
		/// Determines whether the target needs to be updated
		/// </summary>
		/// <param name="projectFiles">
		/// The project's files
		/// <see cref="ProjectFileCollection"/>
		/// </param>
		/// <param name="target">
		/// The target
		/// <see cref="System.String"/>
		/// </param>
		/// <returns>
		/// true if target needs to be updated
		/// <see cref="System.Boolean"/>
		/// </returns>
		private bool NeedsUpdate (ProjectFileCollection projectFiles,
								  string target)
		{
			return true;
		}
Exemplo n.º 49
0
        /// <summary>
        /// Compiles a D project.
        /// </summary>
        public static BuildResult Compile(
            DProject Project,
            ProjectFileCollection FilesToCompile,
            DProjectConfiguration BuildConfig,
            IProgressMonitor monitor)
        {
            var relObjDir = "objs";
            var objDir = Path.Combine(Project.BaseDirectory, relObjDir);

            if(!Directory.Exists(objDir))
                Directory.CreateDirectory(objDir);

            // List of created object files
            var BuiltObjects = new List<string>();
            var compilerResults = new CompilerResults(new TempFileCollection());
            var buildResult = new BuildResult(compilerResults, "");
            bool succesfullyBuilt = true;
            bool modificationsDone = false;

            var Compiler = Project.Compiler;
            var Commands = Compiler.GetTargetConfiguration(Project.CompileTarget);
            var Arguments= Commands.GetArguments(BuildConfig.DebugMode);

            /// The target file to which all objects will be linked to
            var LinkTarget = BuildConfig.OutputDirectory.Combine(BuildConfig.CompiledOutputName);

            monitor.BeginTask("Build Project", FilesToCompile.Count + 1);

            var SourceIncludePaths=new List<string>(Compiler.GlobalParseCache.DirectoryPaths);
                SourceIncludePaths.AddRange(Project.LocalIncludeCache.DirectoryPaths);

            #region Compile sources to objects
            foreach (var f in FilesToCompile)
            {
                if (monitor.IsCancelRequested)
                    return buildResult;

                // If not compilable, skip it
                if (f.BuildAction != BuildAction.Compile || !File.Exists(f.FilePath))
                    continue;

                // a.Check if source file was modified and if object file still exists
                if (Project.LastModificationTimes.ContainsKey(f) &&
                    Project.LastModificationTimes[f] == File.GetLastWriteTime(f.FilePath) &&
                    File.Exists(f.LastGenOutput))
                {
                    // File wasn't edited since last build
                    // but add the built object to the objs array
                    BuiltObjects.Add(f.LastGenOutput);
                    monitor.Step(1);
                    continue;
                }
                else
                    modificationsDone=true;

                #region Resource file
                if(f.Name.EndsWith(".rc",StringComparison.OrdinalIgnoreCase))
                {
                    var res = Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath))+ ".res";

                    if(File.Exists(res))
                        File.Delete(res);

                    // Build argument string
                    var resCmpArgs = FillInMacros(Win32ResourceCompiler.Instance.Arguments,
                        new Win32ResourceCompiler.ArgProvider{
                            RcFile=f.FilePath.ToString(),
                            ResFile=res
                        });

                    // Execute compiler
                    string output;
                    int _exitCode = ExecuteCommand(Win32ResourceCompiler.Instance.Executable,
                        resCmpArgs,
                        Project.BaseDirectory,
                        monitor,
                        out output);

                    // Error analysis
                    if(!string.IsNullOrEmpty(output))
                        compilerResults.Errors.Add(new CompilerError{ FileName=f.FilePath, ErrorText=output});
                    CheckReturnCode(_exitCode, compilerResults);

                    monitor.Step(1);

                    if (_exitCode != 0)
                    {
                        buildResult.FailedBuildCount++;
                        succesfullyBuilt = false;
                        break;
                    }
                    else
                    {
                        f.LastGenOutput = res;
                        buildResult.BuildCount++;
                        Project.LastModificationTimes[f] = File.GetLastWriteTime(f.FilePath);

                        // Especially when compiling large projects, do only add the relative part of the r file due to command shortness
                        if (res.StartsWith(Project.BaseDirectory))
                            BuiltObjects.Add(res.Substring(Project.BaseDirectory.ToString().Length).TrimStart(Path.DirectorySeparatorChar));
                        else
                            BuiltObjects.Add(res);
                    }

                    continue;
                }
                #endregion

                // Create object file path
                var obj = Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath)) + ObjectExtension;

                if (File.Exists(obj))
                    File.Delete(obj);

                // Prevent duplicates e.g. when having the samely-named source files in different sub-packages
                int i=2;
                while(File.Exists(obj))
                {
                    // Simply add a number between the obj name and its extension
                    obj= Path.Combine(objDir, Path.GetFileNameWithoutExtension(f.FilePath))+i + ObjectExtension;
                    i++;
                }

                // Create argument string for source file compilation.
                var dmdArgs = FillInMacros(Arguments.CompilerArguments + " " + BuildConfig.ExtraCompilerArguments,  new DCompilerMacroProvider
                {
                    IncludePathConcatPattern=Commands.IncludePathPattern,
                    SourceFile = f.FilePath,
                    ObjectFile = obj,
                    Includes=SourceIncludePaths,
                });

                // b.Execute compiler
                string dmdOutput;
                int exitCode = ExecuteCommand(Commands.Compiler, dmdArgs, Project.BaseDirectory, monitor, out dmdOutput);

                ParseCompilerOutput(dmdOutput, compilerResults);
                CheckReturnCode(exitCode, compilerResults);

                monitor.Step(1);

                if (exitCode != 0)
                {
                    buildResult.FailedBuildCount++;
                    succesfullyBuilt = false;
                    break;
                }
                else
                {
                    f.LastGenOutput = obj;
                    buildResult.BuildCount++;
                    Project.LastModificationTimes[f] = File.GetLastWriteTime(f.FilePath);

                    // Especially when compiling large projects, do only add the relative part of the obj file due to command shortness
                    if (obj.StartsWith(Project.BaseDirectory))
                        BuiltObjects.Add(obj.Substring(Project.BaseDirectory.ToString().Length).TrimStart(Path.DirectorySeparatorChar));
                    else
                        BuiltObjects.Add(obj);
                }
            }
            #endregion

            #region Link files
            if (succesfullyBuilt)
            {
                // a.
                if ((!modificationsDone) && lastLinkerActionSuccessfull)
                {
                    // Only return if build target is still existing
                    if (File.Exists(LinkTarget))
                    {
                        monitor.Step(1);
                        return new BuildResult(compilerResults, "");
                    }
                }

                // b.Build linker argument string

                // Build argument preparation
                /*
                var libPaths=new List<string>(Compiler.DefaultLibPaths);
                libPaths.AddRange(Project.LibraryPaths);
                */
                var libs=new List<string>(Compiler.DefaultLibraries);
                libs.AddRange(Project.ExtraLibraries);

                var linkArgs = FillInMacros(Arguments.LinkerArguments + " "+BuildConfig.ExtraLinkerArguments,
                    new DLinkerMacroProvider {
                        ObjectsStringPattern=Commands.ObjectFileLinkPattern,
                        Objects=BuiltObjects.ToArray(),
                        TargetFile=LinkTarget,
                        RelativeTargetDirectory=BuildConfig.OutputDirectory.ToRelative(Project.BaseDirectory),

                        //LibraryPaths=libPaths,
                        Libraries=libs
                });
                var linkerOutput = "";
                int exitCode = ExecuteCommand(Commands.Linker,linkArgs,Project.BaseDirectory,monitor,out linkerOutput);

                compilerResults.NativeCompilerReturnValue = exitCode;

                CheckReturnCode(exitCode, compilerResults);

                lastLinkerActionSuccessfull = (exitCode == 0);
                if (lastLinkerActionSuccessfull)
                {
                    monitor.ReportSuccess("Build successful!");
                    monitor.Step(1);
                }
            }
            #endregion

            return new BuildResult(compilerResults,"");
        }
Exemplo n.º 50
0
		public abstract void Clean (ProjectFileCollection projectFiles, CProjectConfiguration configuration, IProgressMonitor monitor);
		public BuildResult Compile (ProjectFileCollection projectFiles, ProjectReferenceCollection projectReferences, DotNetProjectConfiguration configuration, IProgressMonitor monitor)
		{
			NemerleParameters cp = (NemerleParameters) configuration.CompilationParameters;
			if (cp == null) cp = new NemerleParameters ();
			
			string references = "";
			string files   = "";
			
			foreach (ProjectReference lib in projectReferences)
				foreach (string a in lib.GetReferencedFileNames())
					references += " -r \"" + a + "\"";
			
			foreach (ProjectFile f in projectFiles)
				if (f.Subtype != Subtype.Directory)
					switch (f.BuildAction)
					{
						case BuildAction.Compile:
							files += " \"" + f.Name + "\"";
						break;
					}

			if (!Directory.Exists (configuration.OutputDirectory))
				Directory.CreateDirectory (configuration.OutputDirectory);
			
			string args = "-q -no-color " + GetOptionsString (configuration, cp) + references + files  + " -o " + configuration.CompiledOutputName;
			return DoCompilation (args);
		}
Exemplo n.º 52
0
 public BuildResult Compile(ProjectFileCollection projectFiles, ProjectReferenceCollection references, DotNetProjectConfiguration configuration, IProgressMonitor monitor)
 {
     return(compilerServices.Compile(projectFiles, references, configuration, monitor));
 }
Exemplo n.º 53
0
		/// <summary>
		/// Creates a compiler error from an output string
		/// </summary>
		/// <param name="errorString">
		/// The error string to be parsed
		/// <see cref="System.String"/>
		/// </param>
		/// <returns>
		/// A newly created CompilerError
		/// <see cref="CompilerError"/>
		/// </returns>
		private CompilerError CreateErrorFromErrorString (string errorString, ProjectFileCollection projectFiles)
		{
			Match errorMatch = null;
			foreach (Regex regex in new Regex[]{errorRegex, gccRegex})
				if ((errorMatch = regex.Match (errorString)).Success)
					break;
			
			if (!errorMatch.Success)
				return null;

			CompilerError error = new CompilerError ();
			
			foreach (ProjectFile pf in projectFiles) {
				if (Path.GetFileName (pf.Name) == errorMatch.Groups["file"].Value) {
					error.FileName = pf.FilePath;
					break;
				}
			}// check for fully pathed file
			if (string.Empty == error.FileName) {
				error.FileName = errorMatch.Groups["file"].Value;
			}// fallback to exact match
			error.Line = int.Parse (errorMatch.Groups["line"].Value);
			if (errorMatch.Groups["column"].Success)
				error.Column = int.Parse (errorMatch.Groups["column"].Value);
			error.IsWarning = !errorMatch.Groups["level"].Value.Equals (GettextCatalog.GetString ("error"), StringComparison.Ordinal);
			error.ErrorText = errorMatch.Groups["message"].Value;
			
			return error;
		}
		public static void GetFolderContent (string folder, out ProjectFileCollection files, out List<string> folders)
		{
			string folderPrefix = folder + Path.DirectorySeparatorChar;

			files = new ProjectFileCollection ();
			folders = new List<string> ();

			foreach (ProjectFile file in AllFiles)
			{
				string dir;

				if (file.Subtype != Subtype.Directory) {
					if (file.DependsOnFile != null)
						continue;


					dir = 
						//file.IsLink
						//? project.BaseDirectory.Combine (file.ProjectVirtualPath).ParentDirectory
						//: 
						file.FilePath.ParentDirectory;

					if (dir == folder) {
						files.Add (file);
						continue;
					}
				} else
					dir = file.Name;

				// add the directory if it isn't already present
				if (dir.StartsWith (folderPrefix, StringComparison.Ordinal)) {
					int i = dir.IndexOf (Path.DirectorySeparatorChar, folderPrefix.Length);
					if (i != -1) dir = dir.Substring (0,i);
					if (!folders.Contains (dir))
						folders.Add (dir);
				}
			}

		}
		protected void GetContents (MonoDevelop.Projects.Project project, MonoDevelop.Prj2Make.Schema.Csproj.File[] Include, ProjectFileCollection files, IProgressMonitor monitor)
		{
			if (Include == null || Include.Length == 0)
				return;

			// Iterate through the file collection of the csproj file
			foreach(MonoDevelop.Prj2Make.Schema.Csproj.File fl in Include)
			{
				ProjectFile flOut = new ProjectFile ();
				
				string name;
				if ((fl.Link == null) || (fl.Link.Length == 0)) {
					name = MapPath (project.BaseDirectory, fl.RelPath);
				} else {
					name = MapPath (null, fl.Link);
				}
				
				if (name == null) {
					monitor.ReportWarning (GettextCatalog.GetString ("Can't import file: ") + fl.RelPath);
					continue;
				}
				flOut.Name = name;
				// Adding here as GetDefaultResourceIdInternal needs flOut.Project
				files.Add (flOut);
				
				switch (fl.SubType)
				{
					case "Code":
						flOut.Subtype = Subtype.Code;
						break;
				}

				switch (fl.BuildAction)
				{
					case MonoDevelop.Prj2Make.Schema.Csproj.FileBuildAction.Compile:
						flOut.BuildAction = BuildAction.Compile;
						break;
					case MonoDevelop.Prj2Make.Schema.Csproj.FileBuildAction.Content:
						flOut.BuildAction = BuildAction.Content;
						break;
					case MonoDevelop.Prj2Make.Schema.Csproj.FileBuildAction.EmbeddedResource:
						flOut.BuildAction = BuildAction.EmbeddedResource;
						break;
					case MonoDevelop.Prj2Make.Schema.Csproj.FileBuildAction.None:
						flOut.BuildAction = BuildAction.None;
						break;				
				}
				// DependentUpon is relative to flOut
				flOut.DependsOn = MapPath (Path.GetDirectoryName (flOut.Name), fl.DependentUpon);
				flOut.Data = "";
			}
		}
Exemplo n.º 56
0
 public abstract void Clean(ProjectFileCollection projectFiles, CProjectConfiguration configuration, IProgressMonitor monitor);
        public BuildResult Compile(ProjectItemCollection items, DotNetProjectConfiguration configuration, IProgressMonitor monitor)
        {
            FSharpCompilerParameters compilerparameters = (FSharpCompilerParameters) configuration.CompilationParameters;
            if (compilerparameters == null) compilerparameters = new FSharpCompilerParameters ();

            string responseFileName = Path.GetTempFileName();
            StringWriter writer = new StringWriter ();
            ArrayList gacRoots = new ArrayList ();

            AddOption(writer, "--fullpaths");
            AddOption(writer, "--utf8output");

            ProjectFileCollection projectFiles = new ProjectFileCollection();
            ProjectReferenceCollection references = new ProjectReferenceCollection();
            // FIXME: Plain guesswork
            foreach(ProjectItem item in items)
            {
                ProjectFile file = null;
                ProjectReference reference = null;
                if((file = item as ProjectFile) != null)
                {
                    projectFiles.Add(file);
                }
                else if((reference = item as ProjectReference) != null)
                {
                    references.Add(reference);
                }
                else
                {
                    // Nada...
                }
            }

            if (references != null) {
                foreach (ProjectReference lib in references) {
                    if ((lib.ReferenceType == ReferenceType.Project) &&
                        (!(lib.OwnerProject.ParentSolution.FindProjectByName (lib.Reference) is DotNetProject)))
                        continue;
                    foreach (string fileName in lib.GetReferencedFileNames (configuration.Id)) {
                        switch (lib.ReferenceType) {
                        case ReferenceType.Gac:
                            SystemPackage[] pkgs = Runtime.SystemAssemblyService.GetPackagesFromFullName(lib.Reference);
                            SystemPackage pkg = null;
                            if(pkgs != null && pkgs.Length > 0)
                            {
                                // FIXME: Now handling only one package
                                pkg = pkgs[0];
                            }

                            if (pkg == null) {
                                string msg = String.Format (GettextCatalog.GetString ("{0} could not be found or is invalid."), lib.Reference);
                                monitor.ReportWarning (msg);
                                continue;
                            }
                            else if (pkg.IsInternalPackage) {
                                AddOption(writer,"-r \"" + fileName + "\"");
                            }
                            if (pkg.GacRoot != null && !gacRoots.Contains (pkg.GacRoot))
                                gacRoots.Add (pkg.GacRoot);
                            break;
                        default:
                            AddOption(writer,"-r \"" + fileName + "\"");
                            break;
                        }
                    }
                }
            }

            string exe = configuration.CompiledOutputName;
            AddOption(writer,"--out \"" + exe + '"');

            if (configuration.SignAssembly) {
                if (File.Exists (configuration.AssemblyKeyFile))
                    AddOption(writer,"--keyfile \"" + configuration.AssemblyKeyFile + '"');
            }

            if (configuration.DebugMode) {
                AddOption(writer,"--debug");
            }
            else
                if (compilerparameters.Optimize)
                    AddOption(writer,"--optimize");

            if (compilerparameters.CodePage != 0) {
                AddOption(writer,"--codepage " + compilerparameters.CodePage);
            }

            if (compilerparameters.TreatWarningsAsErrors) {
                AddOption(writer,"--warnaserror");
            }

            if (compilerparameters.DefineSymbols.Length > 0) {
                AddOption(writer,"--define " + compilerparameters.DefineSymbols);
            }

            switch (configuration.CompileTarget) {
                case CompileTarget.Exe:
                    AddOption(writer,"--target exe");
                    break;
                case CompileTarget.WinExe:
                    AddOption(writer,"--target winexe");
                    break;
                case CompileTarget.Library:
                    AddOption(writer,"--target library");
                    break;
                case CompileTarget.Module:
                    AddOption(writer,"--target module");
                    break;
            }

            if (compilerparameters.GenerateXmlDocumentation) {
                AddOption(writer,"-doc \"" + Path.ChangeExtension(exe, ".xml") + '"');
            }

            if (!string.IsNullOrEmpty (compilerparameters.AdditionalArguments)) {
                AddOption(writer,compilerparameters.AdditionalArguments);
            }

            if (!string.IsNullOrEmpty (compilerparameters.NoWarnings)) {
                AddOption(writer, String.Format("--nowarn {0}", compilerparameters.NoWarnings));
            }

            foreach (ProjectFile finfo in projectFiles) {
                if (finfo.Subtype == Subtype.Directory)
                    continue;

                switch (finfo.BuildAction) {
                    case BuildAction.Compile:
                        AddOption(writer,'"' + finfo.Name + '"');
                        break;
            //					case BuildAction.EmbedAsResource:
            //						string fname = finfo.Name;
            //						if (String.Compare (Path.GetExtension (fname), ".resx", true) == 0)
            //							fname = Path.ChangeExtension (fname, ".resources");
            //
            //						AddOption(writer,@"""/res:{0},{1}""", fname, finfo.ResourceId);
            //						break;
                    default:
                        continue;
                }
            }

            writer.Close();

            string output = String.Empty;
            string error  = String.Empty;

            File.WriteAllText (responseFileName, writer.ToString ());

            string compilerName;
            try {
                compilerName = GetCompilerName (configuration.ClrVersion);
            } catch (Exception e) {
                string message = "Could not obtain F# compiler";
                monitor.ReportError (message, e);
                return null;
            }

            //string outstr = compilerName + " @" + responseFileName;
            string outstr = compilerName + " "+ writer.ToString ();
            TempFileCollection tf = new TempFileCollection();

            string workingDir = ".";
            if (projectFiles != null && projectFiles.Count > 0) {
                workingDir = projectFiles [0].Project.BaseDirectory;
                if (workingDir == null)
                    // Dummy projects created for single files have no filename
                    // and so no BaseDirectory.
                    // This is a workaround for a bug in
                    // ProcessStartInfo.WorkingDirectory - not able to handle null
                    workingDir = ".";
            }

            LoggingService.LogInfo (compilerName + " " + writer.ToString ());

            int exitCode = DoCompilation (outstr, tf, workingDir, gacRoots, ref output, ref error);

            BuildResult result = ParseOutput(tf, output, error);
            if (result.CompilerOutput.Trim ().Length != 0)
                monitor.Log.WriteLine (result.CompilerOutput);

            //if compiler crashes, output entire error string
            if (result.ErrorCount == 0 && exitCode != 0) {
                if (!string.IsNullOrEmpty (error))
                    result.AddError (error);
                else
                    result.AddError ("The compiler appears to have crashed without any error output.");
            }

            FileService.DeleteFile (responseFileName);
            FileService.DeleteFile (output);
            FileService.DeleteFile (error);
            return result;
        }