public MSBuild.Project Save(MSBuild.ProjectCollection collection, string location) { location = Path.Combine(location, _name); Directory.CreateDirectory(location); var project = new MSBuild.Project(collection); string projectFile = Path.Combine(location, _name) + ProjectType.ProjectExtension; if (_isUserProject) { projectFile += ".user"; } project.Save(projectFile); if (ProjectType != ProjectType.Generic) { var projGuid = Guid.NewGuid(); project.SetProperty("ProjectTypeGuid", TypeGuid.ToString()); project.SetProperty("Name", _name); project.SetProperty("ProjectGuid", projGuid.ToString("B")); project.SetProperty("SchemaVersion", "2.0"); var group = project.Xml.AddPropertyGroup(); group.Condition = " '$(Configuration)' == 'Debug' "; group.AddProperty("DebugSymbols", "true"); group = project.Xml.AddPropertyGroup(); group.Condition = " '$(Configuration)' == 'Release' "; group.AddProperty("DebugSymbols", "false"); } foreach (var processor in ProjectType.Processors) { processor.PreProcess(project); } foreach (var item in Items) { item.Generate(ProjectType, project); } foreach (var processor in ProjectType.Processors) { processor.PostProcess(project); } project.Save(); return(project); }
public override bool Execute() { try { _BE.Project input = new _BE.Project(m_inputFile); bool fFound = false; foreach (ProjectPropertyGroupElement bpg in input.Xml.PropertyGroups) { foreach (ProjectPropertyElement bp in bpg.Properties) { if (string.Compare(bp.Name, "BuildNumber", true) == 0) { bpg.SetProperty(bp.Name, m_buildNumber); fFound = true; break; } } if (fFound) { break; } } input.Save(m_outputFile, Encoding.ASCII); } catch (Exception e) { Log.LogError("Error trying to create release info file {0} at {1}: ({2})", m_inputFile, m_outputFile, e.Message); return(false); } return(true); }
public override bool Execute() { try { _BE.Project input = new _BE.Project(m_inputFile); bool fFound = false; foreach (ProjectPropertyGroupElement bpg in input.Xml.PropertyGroups) { foreach (ProjectPropertyElement bp in bpg.Properties) { if (string.Compare(bp.Name, "BuildNumber", true) == 0) { bpg.SetProperty(bp.Name, m_buildNumber); fFound = true; break; } } if (fFound) break; } input.Save(m_outputFile, Encoding.ASCII); } catch (Exception e) { Log.LogError("Error trying to create release info file {0} at {1}: ({2})", m_inputFile, m_outputFile, e.Message); return false; } return true; }
internal static void generate(string filename, string version, string asmName, string ns, ProjectType type) { Project p = new Project(); string typeDesc = null; p.Xml.DefaultTargets = "Build"; createItemGroup(p, "ProjectConfigurations"); createGlobals(ns, type, p, "Globals"); p.Xml.AddImport(@"$(VCTargetsPath)\Microsoft.Cpp.Default.props"); switch (type) { case ProjectType.ConsoleApp: typeDesc = "Application"; break; case ProjectType.XamlApp: typeDesc = "Application"; break; case ProjectType.ClassLibrary: typeDesc = "DynamicLibrary"; break; default: throw new InvalidOperationException("unhandled projectType: " + type); } createCfgProp(p.Xml, typeDesc, true); createCfgProp(p.Xml, typeDesc, false); p.Xml.AddImport(@"$(VCTargetsPath)\Microsoft.Cpp.props"); addPropertySheetImports(p.Xml); addPropertyGroup(p.Xml, makeCfgCondition(DEBUG, PLATFORM), new Blah2(b2)); addPropertyGroup(p.Xml, makeCfgCondition(RELEASE, PLATFORM), new Blah2(b2)); addItemDefs(p.Xml); const string C_TARGET_RULES = @"$(VCTargetsPath)\Microsoft.Cpp.targets"; var v99 = p.Xml.CreateImportElement(C_TARGET_RULES); p.Xml.AppendChild(v99); p.Save(filename); }
public MockVsHierarchy(int childrenSize, string name, Guid guid, MockVsHierarchy parent) { if (parent == null && MockVsSolution.Solution != null && MockVsSolution.Solution.Root != null) { _parent = MockVsSolution.Solution.Root; } else { _parent = parent; } Guid = guid; SubProjects = new List <MockVsHierarchy>(); FileName = name; Children = new List <string>(); _folders = new List <string>(); AddChildren(childrenSize); if (guid != Guid.Empty && !Directory.Exists(FileName)) { #pragma warning disable 612,618 _project = new Project(ProjectCollection.GlobalProjectCollection); #pragma warning restore 612,618 _project.Save(FileName); FileName = _project.ProjectFileLocation.File; } ExtObject = new MockEnvDteProject(this); }
public void AddIceBuilderToProject(EnvDTE.Project p) { Microsoft.Build.Evaluation.Project project = MSBuildUtils.LoadedProject(p.FullName); if (MSBuildUtils.AddIceBuilderToProject(project)) { if (DTEUtil.IsCppProject(p)) { VCUtil.SetupSliceFilter(p); } else { String includeDirectories = ProjectUtil.GetProperty(p, PropertyNames.IncludeDirectories); if (String.IsNullOrEmpty(includeDirectories)) { ProjectUtil.SetProperty(p, PropertyNames.IncludeDirectories, @"$(IceHome)\slice"); } else if (includeDirectories.IndexOf(@"$(IceHome)\slice") == -1) { ProjectUtil.SetProperty(p, PropertyNames.IncludeDirectories, String.Format(@"$(IceHome)\slice;{0}", includeDirectories)); } ProjectUtil.AddAssemblyReference(p, "Ice"); } p.Save(); IVsHierarchy hier = DTEUtil.GetIVsHierarchy(p); Guid projectGUID = Guid.Empty; IVsSolution.GetGuidOfProject(hier, out projectGUID); IVsSolution.CloseSolutionElement((uint)__VSSLNCLOSEOPTIONS.SLNCLOSEOPT_UnloadProject, hier, 0); project.Save(); IVsSolution4.ReloadProject(ref projectGUID); } }
public static MSbuildResult BuildProject(MsBuildSettings settings, string projectFileName, DirectoryInfo dir) { var result = new MSbuildResult(); var path = Path.Combine(dir.FullName, projectFileName); var project = new Project(path, null, null, new ProjectCollection()); project.SetProperty("CscToolPath", settings.CompilerDirectory.FullName); var includes = new HashSet<string>( project.AllEvaluatedItems .Where(i => i.ItemType == "None" || i.ItemType == "Content") .Select(i => Path.GetFileName(i.EvaluatedInclude.ToLowerInvariant()))); foreach (var dll in settings.WellKnownLibsDirectory.GetFiles("*.dll")) if (!includes.Contains(dll.Name.ToLowerInvariant())) project.AddItem("None", dll.FullName); project.Save(); using (var stringWriter = new StringWriter()) { var logger = new ConsoleLogger(LoggerVerbosity.Minimal, stringWriter.Write, color => { }, () => { }); result.Success = SyncBuild(project, logger); if (result.Success) result.PathToExe = Path.Combine(project.DirectoryPath, project.GetPropertyValue("OutputPath"), project.GetPropertyValue("AssemblyName") + ".exe"); else result.ErrorMessage = stringWriter.ToString(); return result; } }
public void TestBuildEngineAndProject() { UIThreadInvoker.Invoke((ThreadInvoker) delegate() { //Get the global service provider and the dte IServiceProvider sp = VsIdeTestHostContext.ServiceProvider; DTE dte = (DTE)sp.GetService(typeof(DTE)); string destination = Path.Combine(TestContext.TestDir, TestContext.TestName); ProjectNode project = Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true); FieldInfo fi; PropertyInfo pi; pi = typeof(ProjectNode).GetProperty("BuildEngine", BindingFlags.Instance | BindingFlags.NonPublic); pi.SetValue(project, MSBuild.ProjectCollection.GlobalProjectCollection, new object[] { }); fi = typeof(ProjectNode).GetField("buildEngine", BindingFlags.Instance | BindingFlags.NonPublic); Assert.AreEqual <MSBuild.ProjectCollection>(MSBuild.ProjectCollection.GlobalProjectCollection, fi.GetValue(project) as MSBuild.ProjectCollection); project.SetProjectFileDirty(false); MSBuild.Project newBuildProject = new MSBuild.Project(MSBuild.ProjectCollection.GlobalProjectCollection); newBuildProject.Save(Path.GetTempFileName()); pi = typeof(ProjectNode).GetProperty("BuildProject", BindingFlags.Instance | BindingFlags.NonPublic); pi.SetValue(project, newBuildProject, new object[] { }); fi = typeof(ProjectNode).GetField("buildProject", BindingFlags.Instance | BindingFlags.NonPublic); Assert.AreEqual <MSBuild.Project>(newBuildProject, fi.GetValue(project) as MSBuild.Project); }); }
public static void IncludeFileInCurrentProject(string approved) { var p = new Project(GetCurrentProjectFile(approved)); if (!p.Items.Any(i => approved.EndsWith(i.UnevaluatedInclude))) { p.AddItem("Content", approved); p.Save(); } }
private static void addPostBuildEvent(string path) { Project project = new Project(path); project.SetProperty("PostBuildEvent", string.Format( @"""{0}"" "" $(TargetDir) "" "" $(TargetName) "" "" $(SolutionDir) """, Process.GetCurrentProcess().MainModule.FileName)); project.Save(); }
private void RemoveIceBuilderFromProject(IVsProject p) { String path = ProjectUtil.GetProjectFullPath(p); foreach (IVsProject p1 in _buildProjects) { if (path.Equals(ProjectUtil.GetProjectFullPath(p1))) { _buildProjects.Remove(p1); break; } } ProjectUtil.DeleteItems( ProjectUtil.GetGeneratedFiles(p).Aggregate( new List <String>(), (items, kv) => { items.AddRange(kv.Value); return(items); })); if (DTEUtil.IsCSharpProject(p)) { Directory.GetFiles(GetAssembliesDir(GetIceHome()), "*.dll") .ToList() .ForEach(item => { String name = Path.GetFileNameWithoutExtension(item); if (ProjectUtil.HasAssemblyReference(DTEUtil.GetProject(p as IVsHierarchy), name)) { ProjectUtil.RemoveAssemblyReference(DTEUtil.GetProject(p as IVsHierarchy), name); } }); } Microsoft.Build.Evaluation.Project project = MSBuildUtils.LoadedProject(path, DTEUtil.IsCppProject(p), true); MSBuildUtils.RemoveIceBuilderFromProject(project); ProjectUtil.SaveProject(p); Guid projectGUID = Guid.Empty; IVsHierarchy hier = p as IVsHierarchy; IVsSolution.GetGuidOfProject(hier, out projectGUID); IVsSolution.CloseSolutionElement((uint)__VSSLNCLOSEOPTIONS.SLNCLOSEOPT_UnloadProject, hier, 0); project.Save(); try { ProjectCollection.GlobalProjectCollection.UnloadProject(project); } catch (System.Exception) { //expected if the project is not in the global project collection } IVsSolution4.ReloadProject(ref projectGUID); }
int IVsProject.AddItem(uint itemidLoc, VSADDITEMOPERATION dwAddItemOperation, string pszItemName, uint cFilesToOpen, string[] rgpszFilesToOpen, IntPtr hwndDlgOwner, VSADDRESULT[] pResult) { if (Directory.Exists(rgpszFilesToOpen[0])) { AddProject(new MockVsHierarchy(rgpszFilesToOpen[0], this)); } else { Children.Add(rgpszFilesToOpen[0]); if (_project != null) { FileInfo itemFileInfo = new FileInfo(rgpszFilesToOpen[0]); _project.Save(FileName); FileInfo projectFileInfo = new FileInfo(_project.ProjectFileLocation.File); string itemName = itemFileInfo.FullName.Substring(projectFileInfo.Directory.FullName.Length + 1); _project.AddItem("Compile", itemName); _project.Save(FileName); } } return(VSConstants.S_OK); }
private static void UpdateCsprojFile(string fullPath, Project csproj) { try { var fileName = Path.GetFileName(fullPath); File.Delete(fullPath); csproj.Save(fileName); File.Move(csproj.FullPath, fullPath); } catch (IOException) { LogService.WriteError("Erro ao atualizar o arquivo " + fullPath); } }
public void SaveProject(IVsProject project) { Microsoft.Build.Evaluation.Project msproject = project.GetMSBuildProject(true); IVsHierarchy hier = project as IVsHierarchy; Guid projectGUID = Guid.Empty; IVsSolution.GetGuidOfProject(hier, out projectGUID); IVsSolution4.UnloadProject(projectGUID, (uint)_VSProjectUnloadStatus.UNLOADSTATUS_UnloadedByUser); msproject.Save(); try { ProjectCollection.GlobalProjectCollection.UnloadProject(msproject); } catch (Exception) { //expected if the project is not in the global project collection } IVsSolution4.ReloadProject(ref projectGUID); }
private void RemoveIceBuilderFromProject(EnvDTE.Project p) { Microsoft.Build.Evaluation.Project project = MSBuildUtils.LoadedProject(p.FullName); MSBuildUtils.RemoveIceBuilderFromProject(project); foreach (EnvDTE.Project p1 in _buildProjects) { if (p.FullName.Equals(p.FullName)) { _buildProjects.Remove(p1); break; } } ProjectUtil.DeleteItems(p, ProjectUtil.GetGeneratedFiles(p).Aggregate( new List <String>(), (items, kv) => { items.AddRange(kv.Value); return(items); })); Directory.GetFiles(GetAssembliesDir(GetIceHome()), "*.dll") .ToList() .ForEach(item => { String name = Path.GetFileNameWithoutExtension(item); if (ProjectUtil.HasAssemblyReference(p, name)) { ProjectUtil.RemoveAssemblyReference(p, name); } }); p.Save(); Guid projectGUID = Guid.Empty; IVsHierarchy hier = DTEUtil.GetIVsHierarchy(p); IVsSolution.GetGuidOfProject(hier, out projectGUID); IVsSolution.CloseSolutionElement((uint)__VSSLNCLOSEOPTIONS.SLNCLOSEOPT_UnloadProject, hier, 0); project.Save(); IVsSolution4.ReloadProject(ref projectGUID); }
public MSBuild.Project Save(MSBuild.ProjectCollection collection, string location) { location = Path.Combine(location, _name); Directory.CreateDirectory(location); var project = new MSBuild.Project(collection); string projectFile = Path.Combine(location, _name) + ProjectType.ProjectExtension; if (_isUserProject) { projectFile += ".user"; } project.Save(projectFile); if (ProjectType != ProjectType.Generic) { var projGuid = Guid; project.SetProperty("ProjectTypeGuid", TypeGuid.ToString()); project.SetProperty("Name", _name); project.SetProperty("ProjectGuid", projGuid.ToString("B")); project.SetProperty("SchemaVersion", "2.0"); var group = project.Xml.AddPropertyGroup(); group.Condition = " '$(Configuration)' == 'Debug' "; group.AddProperty("DebugSymbols", "true"); group = project.Xml.AddPropertyGroup(); group.Condition = " '$(Configuration)' == 'Release' "; group.AddProperty("DebugSymbols", "false"); } foreach (var processor in ProjectType.Processors) { processor.PreProcess(project); } foreach (var item in Items) { item.Generate(ProjectType, project); } foreach (var processor in ProjectType.Processors) { processor.PostProcess(project); } project.Save(); return project; }
public override bool Execute() { bool result = true; string file = Path.Combine(m_stubsPath, m_name + ".featureproj"); try { _EVAL.Project proj = new _EVAL.Project(); Microsoft.Build.Evaluation.ProjectCollection projCol = proj.ProjectCollection; ProjectPropertyGroupElement bpg = proj.Xml.AddPropertyGroup(); bpg.AddProperty("FeatureName", m_name); bpg.AddProperty("Guid", System.Guid.NewGuid().ToString("B")); bpg.AddProperty("Description", "<Add Feature Description Here>"); bpg.AddProperty("Groups", ""); bpg.AddProperty(m_name.ToUpper().Replace(".", "_") + "_FEATUREPROJ", "True"); ProjectItemGroupElement big = proj.Xml.AddItemGroup(); big.AddItem("InteropFeature", Path.GetFileNameWithoutExtension(m_assemblyName).Replace('.', '_')); big.AddItem("DriverLibs", Path.GetFileNameWithoutExtension(m_assemblyName).Replace('.', '_') + ".$(LIB_EXT)"); big.AddItem("MMP_DAT_CreateDatabase", "$(BUILD_TREE_CLIENT)\\pe\\$(ENDIANNESS)\\" + m_assemblyName); big.AddItem("RequiredProjects", Path.Combine(m_stubsPath, m_nativeProjectFile)); proj.Save(file); // after save, unload the project, so that if rebuilds it is able to regenerate the project file. ProjectRootElement pre = proj.Xml; projCol.UnloadProject(proj); projCol.UnloadProject(pre); } catch (Exception e) { Log.LogError("Error trying to create feature project file \"" + file + "\": " + e.Message); result = false; } return(result); }
public void AddIceBuilderToProject(IVsProject p) { Microsoft.Build.Evaluation.Project project = MSBuildUtils.LoadedProject(ProjectUtil.GetProjectFullPath(p), DTEUtil.IsCppProject(p), true); if (MSBuildUtils.AddIceBuilderToProject(project)) { if (DTEUtil.IsCppProject(p)) { VCUtil.SetupSliceFilter(DTEUtil.GetProject(p as IVsHierarchy)); } else { String includeDirectories = ProjectUtil.GetProperty(p, PropertyNames.IncludeDirectories); if (String.IsNullOrEmpty(includeDirectories)) { ProjectUtil.SetProperty(p, PropertyNames.IncludeDirectories, @"$(IceHome)\slice"); } else if (includeDirectories.IndexOf(@"$(IceHome)\slice") == -1) { ProjectUtil.SetProperty(p, PropertyNames.IncludeDirectories, String.Format(@"$(IceHome)\slice;{0}", includeDirectories)); } ProjectUtil.AddAssemblyReference(DTEUtil.GetProject(p as IVsHierarchy), "Ice"); } ProjectUtil.SaveProject(p); IVsHierarchy hier = p as IVsHierarchy; Guid projectGUID = Guid.Empty; IVsSolution.GetGuidOfProject(hier, out projectGUID); IVsSolution.CloseSolutionElement((uint)__VSSLNCLOSEOPTIONS.SLNCLOSEOPT_UnloadProject, hier, 0); project.Save(); try { ProjectCollection.GlobalProjectCollection.UnloadProject(project); } catch (System.Exception) { //expected if the project is not in the global project collection } IVsSolution4.ReloadProject(ref projectGUID); } }
public static void AddProjectFiles(FilePath ProjectFile, IReadOnlyList <FilePath> files, bool build = false) { var project = new MSEV.Project(ProjectFile); var projectFolder = ProjectFile.Folder; foreach (var file in files) { var itemType = StandardItemTypes.InferItemType(file.FileName); var relativePath = file.Value.Replace(projectFolder.FullPath, String.Empty); if (relativePath.StartsWith("\\")) { relativePath = relativePath.Substring(1); } project.AddItem(itemType, relativePath); } project.Save(); if (build) { project.Build(); } }
private void ToolStripButton3_Click(object sender, EventArgs e) { TreeNode node = treeView1.SelectedNode; if (node.ImageIndex == PROJECT || node.ImageIndex == FOLDER || node.ImageIndex == FOLDER_OPEN) { string path = _filePath.Replace(Path.DirectorySeparatorChar + Path.GetFileName(_filePath) ?? string.Empty, ""); string replace = node.FullPath?.Replace(Path.GetFileName(_filePath) ?? string.Empty, ""); string target = path + replace.Replace("\\", Path.DirectorySeparatorChar.ToString()); if (Directory.Exists(target)) { StringDialog dialog = new StringDialog((text) => !string.IsNullOrEmpty(text)); dialog.Description = "Create Directory Name"; dialog.ShowDialog(); if (dialog.DialogResult == DialogResult.OK) { string newDir = target + Path.DirectorySeparatorChar + dialog.ResultString; if (!Directory.Exists(newDir)) { Directory.CreateDirectory(newDir); string name = replace.Split(Path.DirectorySeparatorChar)[1]; Project proj = _projects[name]; proj.AddItem("Folder", newDir.Replace(path + "\\" + name + "\\", "") + "\\"); proj.Save(); LoadSolution(_solution, _filePath); } else { MessageBox.Show("Created Directory"); } } } } }
//===================================================================== /// <summary> /// Call this method to perform the build on the project. /// </summary> public void Build() { Project msBuildProject = null; ProjectItem projectItem; string resolvedPath, helpFile, languageFile, scriptFile, hintPath, message = null; SandcastleProject originalProject = null; System.Diagnostics.Debug.WriteLine("Build process starting\r\n"); try { taskRunner = new TaskRunner(this); // If the project isn't using final values suitable for the build, create a copy of the // project that is using final values. if(!project.UsingFinalValues) { originalProject = project; project = new SandcastleProject(originalProject.MSBuildProject); } Assembly asm = Assembly.GetExecutingAssembly(); FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(asm.Location); this.ReportProgress(BuildStep.Initializing, "[{0}, version {1}]", fvi.ProductName, fvi.ProductVersion); buildStart = stepStart = DateTime.Now; // The version of MSBuild to use is based on the tools version set in the project msBuildExePath = Path.Combine(ProjectCollection.GlobalProjectCollection.Toolsets.First( t => t.ToolsVersion == project.MSBuildProject.ToolsVersion).ToolsPath, "MSBuild.exe"); // Get the location of the template files templateFolder = ComponentUtilities.ToolsFolder + @"Templates\"; // Make sure we start out in the project's output folder in case the output folder is relative // to it. projectFolder = Path.GetDirectoryName(originalProjectName); if(projectFolder.Length == 0) projectFolder = Directory.GetCurrentDirectory(); projectFolder += @"\"; Directory.SetCurrentDirectory(projectFolder); this.ReportProgress("Creating output and working folders..."); outputFolder = project.OutputPath; if(String.IsNullOrEmpty(outputFolder)) outputFolder = Directory.GetCurrentDirectory(); else outputFolder = Path.GetFullPath(outputFolder); if(!Directory.Exists(outputFolder)) Directory.CreateDirectory(outputFolder); if(outputFolder[outputFolder.Length - 1] != '\\') outputFolder += @"\"; // Create the log file. The log may be in a folder other than the output so make sure it exists // too. if(!Directory.Exists(Path.GetDirectoryName(this.LogFilename))) Directory.CreateDirectory(Path.GetDirectoryName(this.LogFilename)); swLog = new StreamWriter(this.LogFilename); swLog.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<shfbBuild product=\"{0}\" " + "version=\"{1}\" projectFile=\"{2}\" started=\"{3}\">\r\n<buildStep step=\"{4}\">", fvi.ProductName, fvi.ProductVersion, originalProjectName, DateTime.Now, BuildStep.Initializing); if(project.WorkingPath.Path.Length == 0) workingFolder = outputFolder + @"Working\"; else workingFolder = project.WorkingPath; if((project.HelpFileFormat & HelpFileFormats.Website) != 0) BuildProcess.VerifySafePath("OutputPath", outputFolder, projectFolder); // The output folder and the working folder cannot be the same if(workingFolder == outputFolder) throw new BuilderException("BE0030", "The OutputPath and WorkingPath properties cannot be " + "set to the same path"); // Make sure we can find the tools this.FindTools(); // Check for the SHFBROOT environment variable. It may not be present yet if a reboot hasn't // occurred after installation. In such cases, set it to the proper folder for this process so // that projects can be loaded and built. if(Environment.GetEnvironmentVariable("SHFBROOT") == null) { // We won't issue a warning since it may not be defined in some build environments such as // on a build server. In such cases, it is passed in as a command line option to MSBuild. // Storing it in the environment here lets the SHFB build projects work as expected. this.ReportProgress("The SHFBROOT system environment variable was not found. This " + "variable is usually created during installation and may require a reboot. It has " + "been defined temporarily for this process as: SHFBROOT={0}", ComponentUtilities.ToolsFolder); Environment.SetEnvironmentVariable("SHFBROOT", ComponentUtilities.ToolsFolder); } this.ReportProgress("Locating components in the following folder(s):"); if(!String.IsNullOrEmpty(project.ComponentPath)) this.ReportProgress(" {0}", project.ComponentPath); this.ReportProgress(" {0}", Path.GetDirectoryName(project.Filename)); this.ReportProgress(" {0}", ComponentUtilities.ComponentsFolder); this.ReportProgress(" {0}", ComponentUtilities.ToolsFolder); // Get the framework reflection data settings to use for the build reflectionDataDictionary = new ReflectionDataSetDictionary(new[] { project.ComponentPath, Path.GetDirectoryName(project.Filename) }); frameworkReflectionData = reflectionDataDictionary.CoreFrameworkByTitle(project.FrameworkVersion, true); if(frameworkReflectionData == null) throw new BuilderException("BE0071", String.Format(CultureInfo.CurrentCulture, "Unable to locate information for the project framework version '{0}' or a suitable " + "redirected version on this system. See error number help topic for details.", project.FrameworkVersion)); this.ReportProgress("Framework reflection data location: {0}", this.FrameworkReflectionDataFolder); if(!Directory.EnumerateFiles(this.FrameworkReflectionDataFolder, "*.xml").Any()) throw new BuilderException("BE0032", "Reflection data files for the selected framework " + "do not exist yet (" + frameworkReflectionData.Title + "). See help file for " + "details about this error number."); // Warn if a different framework is being used for the build if(frameworkReflectionData.Title != project.FrameworkVersion) this.ReportWarning("BE0072", "Project framework version '{0}' not found. It has been " + "redirected and will use '{1}' instead.", project.FrameworkVersion, frameworkReflectionData.Title); // Get the composition container used to find build components in the rest of the build process componentContainer = ComponentUtilities.CreateComponentContainer(new[] { project.ComponentPath, Path.GetDirectoryName(project.Filename) }, this.CancellationToken); syntaxGenerators = componentContainer.GetExports<ISyntaxGeneratorFactory, ISyntaxGeneratorMetadata>().Select(sf => sf.Metadata).ToList(); buildComponents = componentContainer.GetExports<BuildComponentFactory, IBuildComponentMetadata>().GroupBy(c => c.Metadata.Id).Select(g => g.First()).ToDictionary( key => key.Metadata.Id, value => value.Value); // Figure out which presentation style to use var style = componentContainer.GetExports<PresentationStyleSettings, IPresentationStyleMetadata>().FirstOrDefault(s => s.Metadata.Id.Equals( project.PresentationStyle, StringComparison.OrdinalIgnoreCase)); if(style == null) throw new BuilderException("BE0001", "The PresentationStyle property value of '" + project.PresentationStyle + "' is not recognized as a valid presentation style definition"); presentationStyle = style.Value; this.ReportProgress("Using presentation style '{0}' located in '{1}'", style.Metadata.Id, Path.Combine(presentationStyle.Location, presentationStyle.BasePath ?? String.Empty)); var psErrors = presentationStyle.CheckForErrors(); if(psErrors.Any()) throw new BuilderException("BE0004", String.Format(CultureInfo.CurrentCulture, "The selected presentation style ({0}) is not valid. Reason(s):\r\n{1}", style.Metadata.Id, String.Join("\r\n", psErrors))); // If the presentation style does not support one or more of the selected help file formats, // stop now. if((project.HelpFileFormat & ~presentationStyle.SupportedFormats) != 0) throw new BuilderException("BE0074", String.Format(CultureInfo.CurrentCulture, "The selected presentation style ({0}) does not support one or more of the selected " + "help file formats. Supported formats: {1}", style.Metadata.Id, presentationStyle.SupportedFormats)); // Create the substitution tag replacement handler now as we have everything it needs substitutionTags = new SubstitutionTagReplacement(this); // Load the plug-ins if necessary if(project.PlugInConfigurations.Count != 0 || presentationStyle.PlugInDependencies.Count != 0) this.LoadPlugIns(); this.ExecutePlugIns(ExecutionBehaviors.After); try { if(Directory.Exists(workingFolder)) { // Clear any data from a prior run this.ReportProgress(BuildStep.ClearWorkFolder, "Clearing working folder..."); BuildProcess.VerifySafePath("WorkingPath", workingFolder, projectFolder); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); try { Directory.Delete(workingFolder, true); } catch(IOException ioEx) { this.ReportProgress(" Not all prior output was removed from '{0}': {1}", workingFolder, ioEx.Message); } catch(UnauthorizedAccessException uaEx) { this.ReportProgress(" Not all prior output was removed from '{0}': {1}", workingFolder, uaEx.Message); } this.ExecutePlugIns(ExecutionBehaviors.After); } } // For MS Help Viewer, the HTML Help Name cannot contain periods, ampersands, or pound signs if((project.HelpFileFormat & HelpFileFormats.MSHelpViewer) != 0 && this.ResolvedHtmlHelpName.IndexOfAny(new[] { '.', '#', '&' }) != -1) throw new BuilderException("BE0075", "For MS Help Viewer builds, the HtmlHelpName property " + "cannot contain periods, ampersands, or pound signs as they are not valid in the " + "help file name."); // If the help file is open, it will fail to build so try to get rid of it now before we // get too far into it. helpFile = outputFolder + this.ResolvedHtmlHelpName + ".chm"; if((project.HelpFileFormat & HelpFileFormats.HtmlHelp1) != 0 && File.Exists(helpFile)) File.Delete(helpFile); helpFile = Path.ChangeExtension(helpFile, ".mshc"); if((project.HelpFileFormat & HelpFileFormats.MSHelpViewer) != 0 && File.Exists(helpFile)) File.Delete(helpFile); if((project.HelpFileFormat & HelpFileFormats.Website) != 0) { helpFile = outputFolder + "Index.aspx"; if(File.Exists(helpFile)) File.Delete(helpFile); helpFile = Path.ChangeExtension(helpFile, ".html"); if(File.Exists(helpFile)) File.Delete(helpFile); } helpFile = outputFolder + this.ResolvedHtmlHelpName + ".docx"; if((project.HelpFileFormat & HelpFileFormats.OpenXml) != 0 && File.Exists(helpFile)) File.Delete(helpFile); } catch(IOException ex) { throw new BuilderException("BE0025", "Unable to remove prior build output: " + ex.Message); } catch { throw; } if((project.HelpFileFormat & (HelpFileFormats.Website | HelpFileFormats.Markdown)) != 0) { this.ReportProgress("-------------------------------"); this.ReportProgress("Clearing any prior web/markdown output..."); // Purge all files and folders from the output path except for the working folder and the // build log. Read-only and/or hidden files and folders are ignored as they are assumed to // be under source control. foreach(string file in Directory.EnumerateFiles(outputFolder)) if(!file.EndsWith(Path.GetFileName(this.LogFilename), StringComparison.Ordinal)) if((File.GetAttributes(file) & (FileAttributes.ReadOnly | FileAttributes.Hidden)) == 0) File.Delete(file); else this.ReportProgress(" Ignoring read-only/hidden file {0}", file); foreach(string folder in Directory.EnumerateDirectories(outputFolder)) try { // Ignore the working folder in case it wasn't removed above if(!folder.Equals(workingFolder.Substring(0, workingFolder.Length - 1), StringComparison.OrdinalIgnoreCase)) { // Some source control providers have a mix of read-only/hidden files within a // folder that isn't read-only/hidden (i.e. Subversion). In such cases, leave // the folder alone. if(Directory.EnumerateFileSystemEntries(folder, "*", SearchOption.AllDirectories).Any( f => (File.GetAttributes(f) & (FileAttributes.ReadOnly | FileAttributes.Hidden)) != 0)) { this.ReportProgress(" Did not delete folder '{0}' as it contains " + "read-only or hidden folders/files", folder); } else if((File.GetAttributes(folder) & (FileAttributes.ReadOnly | FileAttributes.Hidden)) == 0) Directory.Delete(folder, true); else this.ReportProgress(" Ignoring read-only/hidden folder {0}", folder); } } catch(IOException ioEx) { this.ReportProgress(" Ignoring folder '{0}': {1}", folder, ioEx.Message); } catch(UnauthorizedAccessException uaEx) { this.ReportProgress(" Ignoring folder '{0}': {1}", folder, uaEx.Message); } } Directory.CreateDirectory(workingFolder); // Validate the documentation source information, gather assembly and reference info, and copy // XML comments files to the working folder. this.ValidateDocumentationSources(); // Transform the shared builder content files language = project.Language; languageFile = Path.Combine(presentationStyle.ResolvePath(presentationStyle.ToolResourceItemsPath), language.Name + ".xml"); this.ReportProgress(BuildStep.GenerateSharedContent, "Generating shared content files ({0}, {1})...", language.Name, language.DisplayName); if(!File.Exists(languageFile)) { languageFile = Path.Combine(presentationStyle.ResolvePath(presentationStyle.ToolResourceItemsPath), "en-US.xml"); // Warn the user about the default being used this.ReportWarning("BE0002", "Help file builder content for the '{0}, {1}' language could " + "not be found. Using 'en-US, English (US)' defaults.", language.Name, language.DisplayName); } // See if the user has translated the Sandcastle resources. If not found, default to US English. languageFolder = Path.Combine(presentationStyle.ResolvePath(presentationStyle.ResourceItemsPath), language.Name); if(Directory.Exists(languageFolder)) languageFolder = language.Name + @"\"; else { // Warn the user about the default being used. The language will still be used for the help // file though. if(language.Name != "en-US") this.ReportWarning("BE0003", "Sandcastle shared content for the '{0}, {1}' language " + "could not be found. Using 'en-US, English (US)' defaults.", language.Name, language.DisplayName); languageFolder = String.Empty; } if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); substitutionTags.TransformTemplate(Path.GetFileName(languageFile), Path.GetDirectoryName(languageFile), workingFolder); File.Move(workingFolder + Path.GetFileName(languageFile), workingFolder + "SHFBContent.xml"); // Copy the stop word list languageFile = Path.Combine(ComponentUtilities.ToolsFolder, @"PresentationStyles\Shared\" + @"StopWordList\" + Path.GetFileNameWithoutExtension(languageFile) +".txt"); File.Copy(languageFile, workingFolder + "StopWordList.txt"); File.SetAttributes(workingFolder + "StopWordList.txt", FileAttributes.Normal); this.ExecutePlugIns(ExecutionBehaviors.After); } // Generate the API filter used by MRefBuilder this.GenerateApiFilter(); // Generate the reflection information this.ReportProgress(BuildStep.GenerateReflectionInfo, "Generating reflection information..."); reflectionFile = workingFolder + "reflection.org"; if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { substitutionTags.TransformTemplate("MRefBuilder.config", templateFolder, workingFolder); scriptFile = substitutionTags.TransformTemplate("GenerateRefInfo.proj", templateFolder, workingFolder); try { msBuildProject = new Project(scriptFile); // Add the references foreach(var r in referenceDictionary.Values) { projectItem = msBuildProject.AddItem(r.Item1, r.Item2, r.Item3)[0]; // Make sure hint paths are correct by adding the project folder to any relative // paths. Skip any containing MSBuild variable references. if(projectItem.HasMetadata(BuildItemMetadata.HintPath)) { hintPath = projectItem.GetMetadataValue(BuildItemMetadata.HintPath); if(!Path.IsPathRooted(hintPath) && hintPath.IndexOf("$(", StringComparison.Ordinal) == -1) { hintPath = FilePath.GetFullPath(Path.Combine(projectFolder, hintPath)); // If the full path length would exceed the system maximums, make it relative // to keep it under the maximum lengths. if(hintPath.Length > 259 || Path.GetDirectoryName(hintPath).Length > 247) hintPath = FolderPath.AbsoluteToRelativePath(workingFolder, hintPath); projectItem.SetMetadataValue(BuildItemMetadata.HintPath, hintPath); } } } // Add the assemblies to document foreach(string assemblyName in assembliesList) msBuildProject.AddItem("Assembly", assemblyName); msBuildProject.Save(scriptFile); } finally { // If we loaded it, we must unload it. If not, it is cached and may cause problems later. if(msBuildProject != null) { ProjectCollection.GlobalProjectCollection.UnloadProject(msBuildProject); ProjectCollection.GlobalProjectCollection.UnloadProject(msBuildProject.Xml); } } this.ExecutePlugIns(ExecutionBehaviors.Before); // Silverlight build targets are only available for 32-bit builds regardless of the framework // version and require the 32-bit version of MSBuild in order to load the target file correctly. if(project.FrameworkVersion.StartsWith("Silverlight", StringComparison.OrdinalIgnoreCase)) taskRunner.Run32BitProject("GenerateRefInfo.proj", false); else taskRunner.RunProject("GenerateRefInfo.proj", false); this.ExecutePlugIns(ExecutionBehaviors.After); } // If this was a partial build used to obtain API information, stop now if(this.PartialBuildType == PartialBuildType.GenerateReflectionInfo) { commentsFiles.Save(); goto AllDone; // Yeah, I know it's evil but it's quick } // Transform the reflection output based on the document model and create the topic manifest this.ReportProgress(BuildStep.TransformReflectionInfo, "Transforming reflection output..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { scriptFile = substitutionTags.TransformTemplate("TransformManifest.proj", templateFolder, workingFolder); this.ExecutePlugIns(ExecutionBehaviors.Before); taskRunner.RunProject("TransformManifest.proj", false); // Change the reflection file extension before running the ExecutionBehaviors.After plug-ins // so that the plug-ins (if any) get the correct filename. reflectionFile = Path.ChangeExtension(reflectionFile, ".xml"); this.ExecutePlugIns(ExecutionBehaviors.After); } else reflectionFile = Path.ChangeExtension(reflectionFile, ".xml"); // If this was a partial build used to obtain information for namespace and namespace group // comments, stop now. if(this.PartialBuildType == PartialBuildType.TransformReflectionInfo) { commentsFiles.Save(); goto AllDone; // Yeah, I know it's evil but it's quick } // Load the transformed reflection information file reflectionFile = workingFolder + "reflection.xml"; // If there is nothing to document, stop the build if(!ComponentUtilities.XmlStreamAxis(reflectionFile, "api").Any()) throw new BuilderException("BE0033", "No APIs found to document. See error topic in " + "help file for details."); // Generate namespace summary information this.GenerateNamespaceSummaries(); // Expand <inheritdoc /> tags? if(commentsFiles.ContainsInheritedDocumentation) { commentsFiles.Save(); // Transform the reflection output. this.ReportProgress(BuildStep.GenerateInheritedDocumentation, "Generating inherited documentation..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { substitutionTags.TransformTemplate("GenerateInheritedDocs.config", templateFolder, workingFolder); scriptFile = substitutionTags.TransformTemplate("GenerateInheritedDocs.proj", templateFolder, workingFolder); this.ExecutePlugIns(ExecutionBehaviors.Before); taskRunner.RunProject("GenerateInheritedDocs.proj", true); this.ExecutePlugIns(ExecutionBehaviors.After); } // This should always be last so that it overrides comments in the project XML comments files commentsFiles.Add(new XmlCommentsFile(workingFolder + "_InheritedDocs_.xml")); } commentsFiles.Save(); this.EnsureOutputFoldersExist(null); // Copy conceptual content files if there are topics or tokens. Tokens can be replaced in // XML comments files so we check for them too. if(this.ConceptualContent.ContentLayoutFiles.Count != 0 || this.ConceptualContent.TokenFiles.Count != 0) { this.ReportProgress(BuildStep.CopyConceptualContent, "Copying conceptual content..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); this.ConceptualContent.CopyContentFiles(this); this.ExecutePlugIns(ExecutionBehaviors.After); } this.ReportProgress(BuildStep.CreateConceptualTopicConfigs, "Creating conceptual topic configuration files..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); this.ConceptualContent.CreateConfigurationFiles(this); this.ExecutePlugIns(ExecutionBehaviors.After); } } else // Create an empty xmlComp folder required by the build configuration Directory.CreateDirectory(Path.Combine(workingFolder, "xmlComp")); // Copy the additional content this.CopyAdditionalContent(); // Merge the conceptual and additional content TOC info this.MergeConceptualAndAdditionalContentTocInfo(); // Generate the intermediate table of contents file. This // must occur prior to running BuildAssembler as the MS Help // Viewer build component is dependent on the toc.xml file. this.ReportProgress(BuildStep.GenerateIntermediateTableOfContents, "Generating intermediate table of contents file..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { scriptFile = substitutionTags.TransformTemplate("GenerateIntermediateTOC.proj", templateFolder, workingFolder); this.ExecutePlugIns(ExecutionBehaviors.Before); taskRunner.RunProject("GenerateIntermediateTOC.proj", false); // Determine the API content placement this.DetermineApiContentPlacement(); // If there is conceptual content, generate the conceptual intermediate TOC if(toc != null) { this.ReportProgress("Generating conceptual content intermediate TOC file..."); toc.SaveToIntermediateTocFile((project.HelpFileFormat & HelpFileFormats.MSHelpViewer) != 0 ? this.RootContentContainerId : null, project.TocOrder, workingFolder + "_ConceptualTOC_.xml"); } this.ExecutePlugIns(ExecutionBehaviors.After); } // Create the Sandcastle configuration file this.ReportProgress(BuildStep.CreateBuildAssemblerConfigs, "Creating Sandcastle configuration files..."); // Add referenced namespaces to the hash set. These are used to ensure just the needed set of // reflection target files are loaded by BuildAssembler and nothing more to save some time and // memory. var rn = this.ReferencedNamespaces; // These are all of the valid namespaces we are interested in. This prevents the methods below // from returning nested types as potential namespaces since they can't tell the difference. HashSet<string> validNamespaces = new HashSet<string>(Directory.EnumerateFiles( this.FrameworkReflectionDataFolder, "*.xml", SearchOption.AllDirectories).Select( f => Path.GetFileNameWithoutExtension(f))); // Get namespaces referenced in the XML comments of the documentation sources foreach(var n in commentsFiles.GetReferencedNamespaces(validNamespaces)) rn.Add(n); // Get namespaces referenced in the reflection data (plug-ins are responsible for adding // additional namespaces if they add other reflection data files). foreach(string n in GetReferencedNamespaces(reflectionFile, validNamespaces)) rn.Add(n); // Get namespaces from the Framework comments files of the referenced namespaces. This adds // references for stuff like designer and support classes not directly referenced anywhere else. foreach(string n in frameworkReflectionData.GetReferencedNamespaces(language, rn, validNamespaces).ToList()) rn.Add(n); // If F# syntax is being generated, add some of the F# namespaces as the syntax sections generate // references to types that may not be there in non-F# projects. if(ComponentUtilities.SyntaxFiltersFrom(syntaxGenerators, project.SyntaxFilters).Any( f => f.Id == "F#")) { rn.Add("Microsoft.FSharp.Core"); rn.Add("Microsoft.FSharp.Control"); } // If there are no referenced namespaces, add System as a default to prevent the build components // from loading the entire set. if(rn.Count == 0) rn.Add("System"); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); this.ReportProgress(" sandcastle.config"); // The configuration varies based on the style. We'll use a common name (sandcastle.config). resolvedPath = presentationStyle.ResolvePath(presentationStyle.ReferenceBuildConfiguration); substitutionTags.TransformTemplate(Path.GetFileName(resolvedPath), Path.GetDirectoryName(resolvedPath), workingFolder); if(!Path.GetFileName(resolvedPath).Equals("sandcastle.config", StringComparison.OrdinalIgnoreCase)) File.Move(workingFolder + Path.GetFileName(resolvedPath), workingFolder + "sandcastle.config"); // The conceptual content configuration file is only created if needed. if(this.ConceptualContent.ContentLayoutFiles.Count != 0) { this.ReportProgress(" conceptual.config"); resolvedPath = presentationStyle.ResolvePath(presentationStyle.ConceptualBuildConfiguration); substitutionTags.TransformTemplate(Path.GetFileName(resolvedPath), Path.GetDirectoryName(resolvedPath), workingFolder); if(!Path.GetFileName(resolvedPath).Equals("conceptual.config", StringComparison.OrdinalIgnoreCase)) File.Move(workingFolder + Path.GetFileName(resolvedPath), workingFolder + "conceptual.config"); } this.ExecutePlugIns(ExecutionBehaviors.After); } // Merge the build component custom configurations this.MergeComponentConfigurations(); commentsFiles = null; // Build the conceptual help topics if(this.ConceptualContent.ContentLayoutFiles.Count != 0) { this.ReportProgress(BuildStep.BuildConceptualTopics, "Building conceptual help topics..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { scriptFile = substitutionTags.TransformTemplate("BuildConceptualTopics.proj", templateFolder, workingFolder); this.ExecutePlugIns(ExecutionBehaviors.Before); taskRunner.RunProject("BuildConceptualTopics.proj", false); this.ExecutePlugIns(ExecutionBehaviors.After); } } // Build the reference help topics this.ReportProgress(BuildStep.BuildReferenceTopics, "Building reference help topics..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { scriptFile = substitutionTags.TransformTemplate("BuildReferenceTopics.proj", templateFolder, workingFolder); this.ExecutePlugIns(ExecutionBehaviors.Before); taskRunner.RunProject("BuildReferenceTopics.proj", false); this.ExecutePlugIns(ExecutionBehaviors.After); } // Combine the conceptual and API intermediate TOC files into one this.CombineIntermediateTocFiles(); // The last part differs based on the help file format if((project.HelpFileFormat & (HelpFileFormats.HtmlHelp1 | HelpFileFormats.Website)) != 0) { this.ReportProgress(BuildStep.ExtractingHtmlInfo, "Extracting HTML info for HTML Help 1 and/or website..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { scriptFile = substitutionTags.TransformTemplate("ExtractHtmlInfo.proj", templateFolder, workingFolder); this.ExecutePlugIns(ExecutionBehaviors.Before); taskRunner.RunProject("ExtractHtmlInfo.proj", true); this.ExecutePlugIns(ExecutionBehaviors.After); } } // Copy the standard help file content. This is done just before compiling the help so that // template files from the presentation style can take advantage of tag substitution. By this // point, we should have everything we could possibly need. this.CopyStandardHelpContent(); if((project.HelpFileFormat & HelpFileFormats.HtmlHelp1) != 0) { // Generate the table of contents and set the default topic this.ReportProgress(BuildStep.GenerateHelpFormatTableOfContents, "Generating HTML Help 1 table of contents file..."); currentFormat = HelpFileFormats.HtmlHelp1; if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); // It got created in the ExtractingHtmlInfo step above // so there is actually nothing to do here. this.ExecutePlugIns(ExecutionBehaviors.After); } // Generate the help file index this.ReportProgress(BuildStep.GenerateHelpFileIndex, "Generating HTML Help 1 index file..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); // It got created in the ExtractingHtmlInfo step above // so there is actually nothing to do here. this.ExecutePlugIns(ExecutionBehaviors.After); } // Generate the help project file this.ReportProgress(BuildStep.GenerateHelpProject, "Generating HTML Help 1 project file..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); substitutionTags.TransformTemplate("Help1x.hhp", templateFolder, workingFolder); this.ExecutePlugIns(ExecutionBehaviors.After); } // Build the HTML Help 1 help file this.ReportProgress(BuildStep.CompilingHelpFile, "Compiling HTML Help 1 file..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { scriptFile = substitutionTags.TransformTemplate("Build1xHelpFile.proj", templateFolder, workingFolder); this.ExecutePlugIns(ExecutionBehaviors.Before); taskRunner.RunProject("Build1xHelpFile.proj", true); this.GatherBuildOutputFilenames(); this.ExecutePlugIns(ExecutionBehaviors.After); } } if((project.HelpFileFormat & HelpFileFormats.MSHelpViewer) != 0) { // The following build steps are executed to allow plug-ins to handle any necessary processing // but nothing actually happens here: // // BuildStep.GenerateHelpFormatTableOfContents // BuildStep.GenerateHelpProject // // For the MS Help Viewer format, there is no project file to compile and the TOC layout is // generated when the help file is ultimately installed using metadata within each topic file. // All of the necessary TOC info is stored in the intermediate TOC file generated prior to // building the topics. The BuildAssembler MSHCComponent inserts the TOC info into each topic // as it is built. this.ReportProgress(BuildStep.GenerateHelpFormatTableOfContents, "Executing informational Generate Table of Contents " + "build step for plug-ins (not used for MS Help Viewer)"); currentFormat = HelpFileFormats.MSHelpViewer; if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); this.ExecutePlugIns(ExecutionBehaviors.After); } this.ReportProgress(BuildStep.GenerateHelpProject, "Executing informational Generate Help Project " + "build step for plug-ins (not used for MS Help Viewer)"); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); this.ExecutePlugIns(ExecutionBehaviors.After); } // Build the MS Help Viewer help file this.ReportProgress(BuildStep.CompilingHelpFile, "Generating MS Help Viewer file..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { substitutionTags.TransformTemplate("HelpContentSetup.msha", templateFolder, workingFolder); // Rename the content setup file to use the help filename to keep them related and // so that multiple output files can be sent to the same output folder. File.Move(workingFolder + "HelpContentSetup.msha", workingFolder + this.ResolvedHtmlHelpName + ".msha"); // Generate the example install and remove scripts substitutionTags.TransformTemplate("InstallMSHC.bat", templateFolder, workingFolder); File.Move(workingFolder + "InstallMSHC.bat", workingFolder + "Install_" + this.ResolvedHtmlHelpName + ".bat"); substitutionTags.TransformTemplate("RemoveMSHC.bat", templateFolder, workingFolder); File.Move(workingFolder + "RemoveMSHC.bat", workingFolder + "Remove_" + this.ResolvedHtmlHelpName + ".bat"); // Copy the launcher utility File.Copy(ComponentUtilities.ToolsFolder + "HelpLibraryManagerLauncher.exe", workingFolder + "HelpLibraryManagerLauncher.exe"); File.SetAttributes(workingFolder + "HelpLibraryManagerLauncher.exe", FileAttributes.Normal); scriptFile = substitutionTags.TransformTemplate("BuildHelpViewerFile.proj", templateFolder, workingFolder); this.ExecutePlugIns(ExecutionBehaviors.Before); taskRunner.RunProject("BuildHelpViewerFile.proj", true); this.GatherBuildOutputFilenames(); this.ExecutePlugIns(ExecutionBehaviors.After); } } if((project.HelpFileFormat & HelpFileFormats.Website) != 0) { // Generate the table of contents and set the default topic this.ReportProgress(BuildStep.GenerateHelpFormatTableOfContents, "Generating website table of contents file..."); currentFormat = HelpFileFormats.Website; if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); // It got created in the ExtractingHtmlInfo step above // so there is actually nothing to do here. this.ExecutePlugIns(ExecutionBehaviors.After); } this.GenerateWebsite(); } if((project.HelpFileFormat & HelpFileFormats.OpenXml) != 0) { // The following build steps are executed to allow plug-ins to handle any necessary processing // but nothing actually happens here: // // BuildStep.GenerateHelpFormatTableOfContents // BuildStep.GenerateHelpProject // // For the Open XML format, there is no project file to compile and the TOC layout is // generated when the document is opened. All of the necessary TOC info is stored in the // intermediate TOC file generated prior to building the topics. The process used to merge // the topics into a single document uses it to define the order in which the topics are // combined. this.ReportProgress(BuildStep.GenerateHelpFormatTableOfContents, "Executing informational " + "Generate Table of Contents build step for plug-ins (not used for Open XML)"); currentFormat = HelpFileFormats.OpenXml; if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); this.ExecutePlugIns(ExecutionBehaviors.After); } this.ReportProgress(BuildStep.GenerateHelpProject, "Executing informational Generate Help " + "Project build step for plug-ins (not used for Open XML)"); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); this.ExecutePlugIns(ExecutionBehaviors.After); } // Build the Open XML document this.ReportProgress(BuildStep.CompilingHelpFile, "Generating Open XML document file..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { scriptFile = substitutionTags.TransformTemplate("BuildOpenXmlFile.proj", templateFolder, workingFolder); this.ExecutePlugIns(ExecutionBehaviors.Before); taskRunner.RunProject("BuildOpenXmlFile.proj", true); this.GatherBuildOutputFilenames(); this.ExecutePlugIns(ExecutionBehaviors.After); } } if((project.HelpFileFormat & HelpFileFormats.Markdown) != 0) { // The following build steps are executed to allow plug-ins to handle any necessary processing // but nothing actually happens here: // // BuildStep.GenerateHelpFormatTableOfContents // BuildStep.GenerateHelpProject // // For the Markdown format, there is no project file to compile and the TOC layout is // generated by the build task. All of the necessary TOC info is stored in the intermediate // TOC file generated prior to building the topics. The build task uses it to find the // topics to finalize and generate the sidebar TOC file. this.ReportProgress(BuildStep.GenerateHelpFormatTableOfContents, "Executing informational " + "Generate Table of Contents build step for plug-ins (not used for Markdown)"); currentFormat = HelpFileFormats.Markdown; if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); this.ExecutePlugIns(ExecutionBehaviors.After); } this.ReportProgress(BuildStep.GenerateHelpProject, "Executing informational Generate Help " + "Project build step for plug-ins (not used for Markdown)"); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); this.ExecutePlugIns(ExecutionBehaviors.After); } // Generate the markdown content this.ReportProgress(BuildStep.CompilingHelpFile, "Generating markdown content..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { scriptFile = substitutionTags.TransformTemplate("GenerateMarkdownContent.proj", templateFolder, workingFolder); this.ExecutePlugIns(ExecutionBehaviors.Before); taskRunner.RunProject("GenerateMarkdownContent.proj", true); this.GatherBuildOutputFilenames(); this.ExecutePlugIns(ExecutionBehaviors.After); } } // All done if(project.CleanIntermediates) { this.ReportProgress(BuildStep.CleanIntermediates, "Removing intermediate files..."); if(!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf)) { this.ExecutePlugIns(ExecutionBehaviors.Before); try { Directory.Delete(workingFolder, true); } catch(IOException ioEx) { this.ReportProgress(" Not all build output was removed from '{0}': {1}", workingFolder, ioEx.Message); } catch(UnauthorizedAccessException uaEx) { this.ReportProgress(" Not all build output was removed from '{0}': {1}", workingFolder, uaEx.Message); } this.ExecutePlugIns(ExecutionBehaviors.After); } } AllDone: TimeSpan runtime = DateTime.Now - buildStart; this.ReportProgress(BuildStep.Completed, "\r\nBuild completed successfully at {0}. " + "Total time: {1:00}:{2:00}:{3:00.0000}\r\n", DateTime.Now, Math.Floor(runtime.TotalSeconds / 3600), Math.Floor((runtime.TotalSeconds % 3600) / 60), (runtime.TotalSeconds % 60)); System.Diagnostics.Debug.WriteLine("Build process finished successfully\r\n"); } catch(OperationCanceledException ) { buildCancelling = true; this.ReportError(BuildStep.Canceled, "BE0064", "BUILD CANCELLED BY USER"); System.Diagnostics.Debug.WriteLine("Build process aborted\r\n"); } catch(Exception ex) { System.Diagnostics.Debug.WriteLine(ex); var agEx = ex as AggregateException; if(agEx != null) foreach(var inEx in agEx.InnerExceptions) { if(message != null) message += "\r\n\r\n"; message += inEx.Message + "\r\n" + inEx.StackTrace; } var bex = ex as BuilderException; do { if(message != null) message += "\r\n\r\n"; message += ex.Message + "\r\n" + ex.StackTrace; ex = ex.InnerException; } while(ex != null); // NOTE: Message may contain format markers so pass it as a format argument if(bex != null) this.ReportError(BuildStep.Failed, bex.ErrorCode, "{0}", message); else this.ReportError(BuildStep.Failed, "BE0065", "BUILD FAILED: {0}", message); System.Diagnostics.Debug.WriteLine("Build process failed\r\n"); } finally { try { this.ExecutePlugIns(ExecutionBehaviors.Before); } catch(Exception ex) { // Not much we can do at this point... this.ReportProgress(ex.ToString()); } try { this.ExecutePlugIns(ExecutionBehaviors.After); if(componentContainer != null) componentContainer.Dispose(); } catch(Exception ex) { // Not much we can do at this point... this.ReportProgress(ex.ToString()); } finally { if(swLog != null) { swLog.WriteLine("</buildStep>\r\n</shfbBuild>"); swLog.Close(); swLog = null; } // If we created a copy of the project, dispose of it and return to the original if(originalProject != null) { project.Dispose(); project = originalProject; } if(this.CurrentBuildStep == BuildStep.Completed && !project.KeepLogFile) File.Delete(this.LogFilename); } } }
/// <summary> /// Adds references to this container from a MSBuild project. /// </summary> public void LoadReferencesFromBuildProject(MSBuild.Project buildProject) { XSharpProjectPackage.Instance.UIThread.MustBeCalledFromUIThread(); List <ReferenceNode> duplicatedNode = new List <ReferenceNode>(); BuildResult buildResult = this.ProjectMgr.Build(MsBuildTarget.ResolveAssemblyReferences); var children = new List <ReferenceNode>(); foreach (string referenceType in SupportedReferenceTypes) { bool isAssemblyReference = referenceType == ProjectFileConstants.Reference; if (isAssemblyReference && !buildResult.IsSuccessful) { continue; } foreach (var item in MSBuildProject.GetItems(buildProject, referenceType)) { ProjectElement element = new ProjectElement(this.ProjectMgr, item, false); ReferenceNode node = CreateReferenceNode(referenceType, element); if (node != null) { // Make sure that we do not want to add the item twice to the ui hierarchy // We are using here the UI representation of the Node namely the Caption to find that out, in order to // avoid different representation problems. // Example :<Reference Include="EnvDTE80, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" /> // <Reference Include="EnvDTE80" /> bool found = false; for (HierarchyNode n = this.FirstChild; n != null && !found; n = n.NextSibling) { if (String.Compare(n.Caption, node.Caption, StringComparison.OrdinalIgnoreCase) == 0) { found = true; break; } } if (!found) { this.AddChild(node); children.Add(node); } else { duplicatedNode.Add(node); } } } } // Now manage duplicates if (duplicatedNode.Count > 0) { // Make a backup first string original = buildProject.FullPath; string backupName = Path.ChangeExtension(original, ".backup"); if (Utilities.DeleteFileSafe(backupName)) { File.Copy(original, backupName); } foreach (ReferenceNode node in duplicatedNode) { //this.RemoveChild( node ); node.Remove(false); } buildProject.Save(original); } var references = buildResult.ProjectInstance.GetItems(ProjectFileConstants.ReferencePath); //var references = MSBuildProjectInstance.GetItems(buildResult.ProjectInstance, ProjectFileConstants.ReferencePath); foreach (var reference in references) { string fullName = MSBuildItem.GetEvaluatedInclude(reference); string name = Path.GetFileNameWithoutExtension(fullName); foreach (var child in children) { if (child is XSharpAssemblyReferenceNode && child.Caption == name) { var xChild = child as XSharpAssemblyReferenceNode; xChild.AssemblyPath = fullName; xChild.SetHintPathAndPrivateValue(buildResult.ProjectInstance, reference); } } } }
internal void CreateSolutionDirProj(MFSolution solution) { string solutionDir = @"$(SPOCLIENT)\Solutions\" + solution.Name; string fullpath = ExpandEnvVars(Path.Combine(solutionDir, "dotnetmf.proj"), ""); Project proj = LoadProject(fullpath); proj.ProjectCollection.UnloadProject(proj); proj = new Project(); proj.Xml.DefaultTargets = "Build"; try { ProjectPropertyGroupElement bpg = proj.Xml.AddPropertyGroup(); bpg.AddProperty("Directory", RemoveSpoClient(solutionDir)); bpg.AddProperty("MFSettingsFile", Path.Combine(solutionDir, solution.Name + ".settings")); ProjectItemGroupElement big = proj.Xml.AddItemGroup(); foreach (MFProject mfproj in solution.Projects) { if (!string.IsNullOrEmpty(mfproj.Directory) && !string.IsNullOrEmpty(mfproj.ProjectPath)) { ProjectItemElement bi = big.AddItem("RequiredProjects", Path.Combine(Path.GetFileName(mfproj.Directory), Path.GetFileName(mfproj.ProjectPath))); } } proj.Xml.AddImport(@"$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Settings"); proj.Xml.AddImport(@"$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Targets"); proj.Save(fullpath); } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Error: loading LibCat file: " + fullpath + "\r\n", e.Message); } }
internal void SaveSolutionProj(MFSolution solution) { if (!string.IsNullOrEmpty(solution.ProjectPath)) { try { //if(File.Exists(solution.ProjectPath) string fullpath = ExpandEnvVars(solution.ProjectPath, ""); Project proj = LoadProject(fullpath); proj.ProjectCollection.UnloadProject(proj); proj = new Project(); proj.Xml.DefaultTargets = "Build"; string dir = Path.GetDirectoryName(fullpath); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } ProjectPropertyGroupElement mainGrp = proj.Xml.AddPropertyGroup(); mainGrp.AddProperty("Author", solution.Author); mainGrp.AddProperty("Description", solution.Description); mainGrp.AddProperty("Documentation", solution.Documentation); mainGrp.AddProperty("PlatformGuid", solution.Guid); if (solution.DefaultISA != null && solution.DefaultISA.Name != null) { ProjectPropertyElement bp = mainGrp.AddProperty("INSTRUCTION_SET", solution.DefaultISA.Name); bp.Condition = solution.DefaultISA.Conditional; } mainGrp.AddProperty("TARGETPLATFORM", solution.Name); mainGrp.AddProperty("PLATFORM", solution.Name); mainGrp.AddProperty("IsSolutionWizardVisible", solution.IsSolutionWizardVisible.ToString()); mainGrp.AddProperty("ENDIANNESS", solution.ENDIANNESS.ToString()); Dictionary<string,object> nameLookup = new Dictionary<string,object>(); foreach (MFProperty prop in solution.Properties) { switch (prop.Name.ToLower()) { case "author": case "description": case "documentation": case "platformguid": case "targetplatform": case "platform": case "issolutionwizardvisible": case "endianness": case "tcp_ip_stack": case "instruction_set": // these properties are reset in this method - this prevents duplication break; default: string key = prop.Name.ToLower(); if(!nameLookup.ContainsKey(key)) { ProjectPropertyElement bp = mainGrp.AddProperty(prop.Name, prop.Value); bp.Condition = prop.Condition; nameLookup[key] = bp; } break; } } MFProject defProj = null; foreach (MFProject prj in solution.Projects) { if (prj.IsClrProject) { defProj = prj; break; } } if (defProj != null) { /// /// If we have the LWIP feature project then we need to add the following property to the /// solutions settings file /// bool AddLWIP = false; foreach (MFComponent f in defProj.Features) { if (f.Name.Equals("Network (RTIP)", StringComparison.InvariantCultureIgnoreCase)) { AddLWIP = false; break; } else if (f.Name.Equals("Network (LWIP)", StringComparison.InvariantCultureIgnoreCase)) { AddLWIP = true; } } if (AddLWIP) { mainGrp.AddProperty("TCP_IP_STACK", "LWIP"); } } ProjectItemGroupElement big = proj.Xml.AddItemGroup(); string solPath = RemoveSpoClient(Path.GetDirectoryName(solution.ProjectPath)); bool fFoundSolPath = false; foreach (MFBuildFile item in solution.Items) { if (string.Equals(item.ItemName, "IncludePaths", StringComparison.InvariantCultureIgnoreCase) && string.Equals(item.File, solPath, StringComparison.InvariantCultureIgnoreCase)) { fFoundSolPath = true; } ProjectItemElement bi = big.AddItem(item.ItemName, item.File); bi.Condition = item.Condition; } if (!fFoundSolPath) { big.AddItem("IncludePaths", solPath); } Processor prc = null; if (!string.IsNullOrEmpty(solution.Processor.Guid)) { prc = m_helper.FindProcessor(solution.Processor.Guid); } else { prc = m_helper.FindProcessorByName(solution.Processor.Name); if (prc != null) { solution.Processor.Guid = prc.Guid; solution.Processor.Name = prc.Name; solution.Processor.ProjectPath = prc.ProjectPath; } } if (prc != null) { proj.Xml.AddImport(prc.ProjectPath); } proj.Save(fullpath); if (solution.m_cloneSolution != null) { string cloneRoot = Path.GetDirectoryName(ExpandEnvVars(solution.m_cloneSolution.ProjectPath, "")) + "\\"; string newRoot = Path.GetDirectoryName(ExpandEnvVars(solution.ProjectPath, "")) + "\\"; CopyClonedFile(cloneRoot + "platform_selector.h", newRoot + "platform_selector.h", solution.m_cloneSolution.Name, solution.Name); /// /// Copy the LWIP_selector file for the cloned solution /// if (File.Exists(cloneRoot + "lwip_selector.h")) { CopyClonedFile(cloneRoot + "lwip_selector.h", newRoot + "lwip_selector.h", solution.m_cloneSolution.Name, solution.Name); } //CopyClonedFile(cloneRoot + "dotnetmf.proj", newRoot + "dotnetmf.proj", solution.m_cloneSolution.Name, solution.Name); //CopyClonedFiles(cloneRoot + "DeviceCode\\", newRoot + "DeviceCode\\", solution.m_cloneSolution.Name, solution.Name); } /// /// copy the generic lwip_selector file in the case the cloned solution doesn't have one or we are creating a /// new solution with LWIP /// if (!File.Exists(Path.Combine(dir, "lwip_selector.h"))) { string lwipSel = ExpandEnvVars("$(SPOCLIENT)\\DeviceCode\\PAL\\LWIP\\Config\\lwip_selector.h", ""); if (File.Exists(lwipSel) && defProj != null) { foreach (MFComponent f in defProj.Features) { if (f.Name.Equals("Network (LWIP)", StringComparison.InvariantCultureIgnoreCase)) { CopyClonedFile(lwipSel, Path.Combine(dir, "lwip_selector.h"), "<TEMPLATE>", solution.Name); break; } } } } string platSelectorFile = Path.Combine(dir, "platform_selector.h"); bool fNewSelector = false; if (!File.Exists(platSelectorFile)) { Processor proc = m_helper.FindProcessor(solution.Processor.Guid); if(proc != null) { string template = Path.GetDirectoryName(ExpandEnvVars(proc.ProjectPath, "")) + "\\" + proc.Name + "_template_selector.h"; string newRoot = Path.GetDirectoryName(ExpandEnvVars(solution.ProjectPath, "")) + "\\"; if (File.Exists(template)) { CopyClonedFile(template, newRoot + "platform_selector.h", "<TEMPLATE>", solution.Name); fNewSelector = true; } } } // only modify if we are cloning or creating a new solution if (File.Exists(platSelectorFile)) { if (fNewSelector || (solution.m_cloneSolution != null)) { FileAttributes attribs = File.GetAttributes(platSelectorFile); if (0 != (attribs & FileAttributes.ReadOnly)) { throw new Exception("File Access Exception: File " + platSelectorFile + " is not accessible"); } string tmpFile = Path.GetTempFileName(); using (TextWriter tw = File.CreateText(tmpFile)) { using (TextReader tr = File.OpenText(platSelectorFile)) { string data = tr.ReadToEnd(); Regex rx = new Regex("#define\\s+SYSTEM_CLOCK_HZ\\s+[^\\r^\\n]+", RegexOptions.Singleline); data = rx.Replace(data, "#define SYSTEM_CLOCK_HZ " + solution.SystemClockSpeed.ToString()); rx = new Regex("#define\\s+SLOW_CLOCKS_PER_SECOND\\s+[^\\r^\\n]+", RegexOptions.Singleline); data = rx.Replace(data, "#define SLOW_CLOCKS_PER_SECOND " + solution.SlowClockSpeed.ToString()); rx = new Regex("#define\\s+SRAM1_MEMORY_Base\\s+[^\\r^\\n]+", RegexOptions.Singleline); data = rx.Replace(data, "#define SRAM1_MEMORY_Base 0x" + solution.RamBase.ToString("X08")); rx = new Regex("#define\\s+SRAM1_MEMORY_Size\\s+[^\\r^\\n]+", RegexOptions.Singleline); data = rx.Replace(data, "#define SRAM1_MEMORY_Size 0x" + solution.RamLength.ToString("X08")); rx = new Regex("#define\\s+FLASH_MEMORY_Base\\s+[^\\r^\\n]+", RegexOptions.Singleline); data = rx.Replace(data, "#define FLASH_MEMORY_Base 0x" + solution.FlashBase.ToString("X08")); rx = new Regex("#define\\s+FLASH_MEMORY_Size\\s+[^\\r^\\n]+", RegexOptions.Singleline); data = rx.Replace(data, "#define FLASH_MEMORY_Size 0x" + solution.FlashLength.ToString("X08")); rx = new Regex("#define\\s+DEBUG_TEXT_PORT\\s+[^\\s]+", RegexOptions.Singleline); data = rx.Replace(data, "#define DEBUG_TEXT_PORT " + solution.DebuggerPort); rx = new Regex("#define\\s+STDIO\\s+[\\w\\d_]+"); data = rx.Replace(data, "#define STDIO " + solution.DebuggerPort); rx = new Regex("#define\\s+DEBUGGER_PORT\\s+[^\\s]+", RegexOptions.Singleline); data = rx.Replace(data, "#define DEBUGGER_PORT " + solution.DebuggerPort); rx = new Regex("#define\\s+MESSAGING_PORT\\s+[^\\s]+", RegexOptions.Singleline); data = rx.Replace(data, "#define MESSAGING_PORT " + solution.DebuggerPort); rx = new Regex("#define\\s+RUNTIME_MEMORY_PROFILE__[\\w]+", RegexOptions.Singleline); data = rx.Replace(data, "#define RUNTIME_MEMORY_PROFILE__" + solution.MemoryProfile); tw.Write(data); } } File.Delete(platSelectorFile); File.Move(tmpFile, platSelectorFile); } } else { using (TextWriter tw = File.CreateText(platSelectorFile)) { tw.WriteLine(string.Format("#ifndef _PLATFORM_{0}_SELECTOR_H_\r\n#define _PLATFORM_{0}_SELECTOR_H_ 1", solution.Name)); tw.WriteLine(string.Format("#define HAL_SYSTEM_NAME \"{0}\"", solution.Name)); tw.WriteLine(string.Format("#define PLATFORM_{0} ", prc.Name.ToUpper())); tw.WriteLine(string.Format("#define PLATFORM_{0}_{1}", prc.PlatformFamily.ToUpper(), prc.Name.ToUpper())); tw.WriteLine(string.Format("#define PLATFORM_{0}_{1}", prc.PlatformFamily.ToUpper(), solution.Name.ToUpper())); if (0 == string.Compare(prc.Name, "MC9328", true)) { tw.WriteLine("#define PLATFORM_ARM_MC9328MXL"); } tw.WriteLine("#define PLATFORM_SUPPORTS_SOFT_REBOOT TRUE"); tw.WriteLine(string.Format("#define SYSTEM_CLOCK_HZ {0}", solution.SystemClockSpeed)); tw.WriteLine(string.Format("#define SLOW_CLOCKS_PER_SECOND {0}", solution.SlowClockSpeed)); tw.WriteLine("#define CLOCK_COMMON_FACTOR 1"); tw.WriteLine("#define SLOW_CLOCKS_TEN_MHZ_GCD 1"); tw.WriteLine("#define SLOW_CLOCKS_MILLISECOND_GCD 1"); tw.WriteLine(string.Format("#define SRAM1_MEMORY_Base 0x{0:X08}", solution.RamBase)); tw.WriteLine(string.Format("#define SRAM1_MEMORY_Size 0x{0:X08}", solution.RamLength)); tw.WriteLine(string.Format("#define FLASH_MEMORY_Base 0x{0:X08}", solution.FlashBase)); tw.WriteLine(string.Format("#define FLASH_MEMORY_Size 0x{0:X08}", solution.FlashLength)); tw.WriteLine(@" #define TXPROTECTRESISTOR RESISTOR_DISABLED #define RXPROTECTRESISTOR RESISTOR_DISABLED #define CTSPROTECTRESISTOR RESISTOR_DISABLED #define RTSPROTECTRESISTOR RESISTOR_DISABLED "); tw.WriteLine(@" #define GLOBAL_LOCK(x) SmartPtr_IRQ x #define DISABLE_INTERRUPTS() SmartPtr_IRQ::ForceDisabled() #define ENABLE_INTERRUPTS() SmartPtr_IRQ::ForceEnabled() #define INTERRUPTS_ENABLED_STATE() SmartPtr_IRQ::GetState() #define GLOBAL_LOCK_SOCKETS(x) SmartPtr_IRQ x #if defined(_DEBUG) #define ASSERT_IRQ_MUST_BE_OFF() ASSERT(!SmartPtr_IRQ::GetState()) #define ASSERT_IRQ_MUST_BE_ON() ASSERT( SmartPtr_IRQ::GetState()) #else #define ASSERT_IRQ_MUST_BE_OFF() #define ASSERT_IRQ_MUST_BE_ON() #endif #define TOTAL_USART_PORT 1 #define COM1 ConvertCOM_ComHandle(0) #define COM2 ConvertCOM_ComHandle(1) #define TOTAL_USB_CONTROLLER 1 #define USB1 ConvertCOM_UsbHandle(0) #define TOTAL_SOCK_PORT 0 #define TOTAL_DEBUG_PORT 1 #define COM_DEBUG ConvertCOM_DebugHandle(0) #define COM_MESSAGING ConvertCOM_MessagingHandle(0) #define USART_TX_IRQ_INDEX(x) ( (x) ? 0 : 0 ) // TODO set right indexes #define USART_DEFAULT_PORT COM1 #define USART_DEFAULT_BAUDRATE 115200 #define USB_IRQ_INDEX 0 // TODO set right index #define PLATFORM_DEPENDENT_TX_USART_BUFFER_SIZE 512 // there is one TX for each usart port #define PLATFORM_DEPENDENT_RX_USART_BUFFER_SIZE 512 // there is one RX for each usart port #define PLATFORM_DEPENDENT_USB_QUEUE_PACKET_COUNT 32 // there is one queue for each pipe of each endpoint and the size of a single packet is sizeof(USB_PACKET64) == 68 bytes "); tw.WriteLine(string.Format("#define DEBUG_TEXT_PORT {0}", solution.DebuggerPort)); tw.WriteLine(string.Format("#define STDIO {0}", solution.DebuggerPort)); tw.WriteLine(string.Format("#define DEBUGGER_PORT {0}", solution.DebuggerPort)); tw.WriteLine(string.Format("#define MESSAGING_PORT {0}", solution.DebuggerPort)); tw.WriteLine(string.Format("#define RUNTIME_MEMORY_PROFILE__{0} 1", solution.MemoryProfile)); tw.WriteLine("#include <processor_selector.h>"); tw.WriteLine(string.Format("#endif // _PLATFORM_{0}_SELECTOR_H_ 1", solution.Name)); } } //foreach (MFProject prj in solution.Projects) //{ // SaveProjectProj(prj); //} } catch { Console.WriteLine("Error: Unable to save solution file " + solution.ProjectPath); } } }
internal void SaveProcessorProj(Processor proc) { if (!string.IsNullOrEmpty(proc.ProjectPath)) { try { string fullpath = ExpandEnvVars(proc.ProjectPath, ""); Project proj = LoadProject(fullpath); proj.ProjectCollection.UnloadProject(proj); proj = new Project(); proj.Xml.DefaultTargets = "Build"; Dictionary<string, string> tbl = new Dictionary<string, string>(); tbl["PlatformFamily"] = "PLATFORM_FAMILY"; ProjectPropertyGroupElement bpg = SaveStringProps(proj, proc, tbl); if (!string.IsNullOrEmpty(proc.DefaultISA)) { ProjectPropertyElement bp = bpg.AddProperty("INSTRUCTION_SET", proc.DefaultISA); bp.Condition = "'$(INSTRUCTION_SET)'==''"; } foreach (MFProperty prop in proc.Properties) { ProjectPropertyElement bp = bpg.AddProperty(prop.Name, prop.Value); bp.Condition = prop.Condition; } bpg.AddProperty("TARGETPROCESSOR", proc.Name); bpg.AddProperty("TARGETCODEBASE", proc.Name); bpg.AddProperty("TARGETCODEBASETYPE", "Native"); SaveBuildToolRef(proc.BuildToolOptions, proj); ProjectItemGroupElement big = proj.Xml.AddItemGroup(); big.AddItem("IncludePaths", RemoveSpoClient(Path.GetDirectoryName(proc.ProjectPath))); //ProjectPropertyGroupElement bpg = proj.Xml.AddPropertyGroup(); //bpg.AddProperty("PKUI_Processor", SerializeXml(proc)); proj.Save(fullpath); } catch(Exception e) { System.Diagnostics.Debug.WriteLine("Error: Unable to save procesor file " + proc.ProjectPath + "\r\n" + e.Message); } } }
private void SaveDependentLibs(Project proj, List<MFComponent> deps) { foreach (MFComponent comp in deps) { if (comp.ComponentType == MFComponentType.Library) { ProjectItemGroupElement big = proj.Xml.AddItemGroup(); Library lib = null; if (!string.IsNullOrEmpty(comp.ProjectPath) && Path.GetExtension(comp.ProjectPath).ToUpper() == ".PROJ") { lib = LoadLibraryProj(comp.ProjectPath, Path.GetDirectoryName(proj.FullPath), true); } if (lib == null) { lib = m_helper.FindLibrary(comp); } if (lib != null) { string tag = "DriverLibs"; string condProj = comp.Conditional; string condLib = comp.Conditional; if (lib.PlatformIndependent) { tag = "PlatformIndependentLibs"; } // normalize the path (no xxx\..\yyy in the path) if (string.IsNullOrEmpty(lib.ProjectPath)) { lib.ProjectPath = comp.ProjectPath; } string fullpath = ExpandEnvVars(lib.ProjectPath, ""); fullpath = Path.GetFullPath(fullpath); fullpath = ConvertPathToEnv(fullpath); ProjectItemElement bi2 = big.AddItem("RequiredProjects", fullpath); bi2.Condition = condProj; ProjectItemElement bi = big.AddItem(tag, lib.LibraryFile); bi.Condition = condLib; proj.Save(proj.FullPath); } else { Console.WriteLine("Error: unknown library dependency while saving project file " + comp.Name); } } else { Console.WriteLine("Error: unexpected component dependency while saving project file " + comp.Name); } } }
public override bool Execute() { bool result = true; string file = Path.Combine(m_stubsPath, m_name + ".featureproj"); try { _EVAL.Project proj = new _EVAL.Project(); Microsoft.Build.Evaluation.ProjectCollection projCol = proj.ProjectCollection; ProjectPropertyGroupElement bpg = proj.Xml.AddPropertyGroup(); bpg.AddProperty("FeatureName", m_name); bpg.AddProperty("Guid", System.Guid.NewGuid().ToString("B")); bpg.AddProperty("Description", "<Add Feature Description Here>"); bpg.AddProperty("Groups", ""); ProjectItemGroupElement big = proj.Xml.AddItemGroup(); big.AddItem("InteropFeature", Path.GetFileNameWithoutExtension(m_assemblyName).Replace('.', '_')); big.AddItem("DriverLibs", Path.GetFileNameWithoutExtension(m_assemblyName).Replace('.', '_') + ".$(LIB_EXT)"); big.AddItem("MMP_DAT_CreateDatabase", "$(BUILD_TREE_CLIENT)\\pe\\$(ENDIANNESS)\\" + m_assemblyName); big.AddItem("RequiredProjects", Path.Combine(m_stubsPath, m_nativeProjectFile)); proj.Save(file); // after save, unload the project, so that if rebuilds it is able to regenerate the project file. ProjectRootElement pre = proj.Xml; projCol.UnloadProject(proj); projCol.UnloadProject(pre); } catch (Exception e) { Log.LogError("Error trying to create feature project file \"" + file + "\": " + e.Message); result = false; } return result; }
public static string createProjectFile(this string projectName, string sourceFile, string pathToAssemblies, string targetDir, List<string> extraEmbebbedResources, Action<List<string>> beforeAddingReferences, Action<List<string>> beforeEmbedingFiles) { var apiCreateExe = new API_Create_Exe(); if (sourceFile.empty()) return null; sourceFile.file_Copy(targetDir); var assemblyFiles = pathToAssemblies.files(false,"*.dll","*.exe"); var projectFile = targetDir.pathCombine(projectName + ".csproj"); var projectCollection = new ProjectCollection(); var outputPath = "bin"; Project project = new Project(projectCollection); project.SetProperty("DefaultTargets", "Build"); var propertyGroup = project.Xml.CreatePropertyGroupElement(); project.Xml.InsertAfterChild(propertyGroup, project.Xml.LastChild); //propertyGroup.AddProperty("TargetFrameworkVersion", "v4.0"); propertyGroup.AddProperty("TargetFrameworkVersion", "v4.5"); propertyGroup.AddProperty("ProjectGuid", Guid.NewGuid().str()); propertyGroup.AddProperty("OutputType", "WinExe"); propertyGroup.AddProperty("OutputPath", outputPath); propertyGroup.AddProperty("AssemblyName", projectName); propertyGroup.AddProperty("PlatformTarget", "x86"); var targets = project.Xml.AddItemGroup(); targets.AddItem("Compile", sourceFile.fileName()); var references = project.Xml.AddItemGroup(); references.AddItem("Reference", "mscorlib"); references.AddItem("Reference", "System"); references.AddItem("Reference", "System.Core"); references.AddItem("Reference", "System.Windows.Forms"); beforeAddingReferences.invoke(assemblyFiles); foreach(var assemblyFile in assemblyFiles) { var assembly = assemblyFile.fileName().assembly(); // first load from local AppDomain (so that we don't lock the dll in the target folder) if (assembly.isNull()) assembly = assemblyFile.assembly(); //only load the O2 assemblies if (assembly.str().lower().contains("o2") || assembly.str().lower().contains("fluentsharp")) { var item = references.AddItem("Reference",assemblyFile.fileName_WithoutExtension()); item.AddMetadata("HintPath",assemblyFile.fileName()); item.AddMetadata("Private",@"False"); } } var gzAssemblyFiles = new List<string>(); beforeEmbedingFiles.invoke(assemblyFiles); var embeddedResources = project.Xml.AddItemGroup(); foreach(var assemblyFile in gzAssemblyFiles) embeddedResources.AddItem("EmbeddedResource",assemblyFile.fileName()); var defaultIcon = "O2Logo.ico"; extraEmbebbedResources.add(assemblyFiles); foreach(var extraResource in extraEmbebbedResources) { if (extraResource.extension(".dll") || extraResource.extension(".exe")) { //ignore these since they are already embded in the FluentSharp.REPL.exe dll if(extraEmbebbedResources.fileNames().contains("FluentSharp.REPL.exe") && (extraResource.contains("Mono.Cecil.dll" ))) { continue; } var gzFile = targetDir.pathCombine(extraResource.fileName() + ".gz"); extraResource.fileInfo().compress(gzFile); extraResource.file_Copy(targetDir); embeddedResources.AddItem("EmbeddedResource",gzFile.fileName()); } else { extraResource.file_Copy(targetDir); embeddedResources.AddItem("EmbeddedResource",extraResource.fileName()); if (extraResource.extension(".ico")) defaultIcon = extraResource; } } //add two extra folders (needs refactoring) Action<string> addSpecialResources = (resourceFolder)=>{ var folder = targetDir.pathCombine(resourceFolder); if (folder.dirExists()) { "found {0} Folder so adding it as a zip:{1}".debug(resourceFolder, folder); var zipFile = folder.zip_Folder(folder + ".zip"); embeddedResources.AddItem("EmbeddedResource",zipFile.fileName()); if (folder.files("*.ico").size()>0) { var icon = folder.files("*.ico").first(); "Found default application ICON: {0}".debug(icon); defaultIcon = icon; } } }; addSpecialResources("O2.Platform.Scripts"); //now add the icon propertyGroup.AddProperty("ApplicationIcon", defaultIcon); var importElement = project.Xml.CreateImportElement(@"$(MSBuildToolsPath)\Microsoft.CSharp.targets"); project.Xml.InsertAfterChild(importElement, project.Xml.LastChild); project.Save(projectFile); var o2Logo = apiCreateExe.path_O2Logo_Icon(); o2Logo.file_Copy(targetDir); return projectFile; }
private void UpdateProjectFileReferenceHintPaths(DirectoryInfo solutionRoot, Project project, string projectPath, IEnumerable<KeyValuePair<string, List<IPackage>>> resolvedMappings, ICollection<ProjectItem> references) { foreach (var mapping in resolvedMappings) { var referenceMatch = references.FirstOrDefault(r => ResolveProjectReferenceItemByAssemblyName(r, mapping.Key)); if (referenceMatch != null) { var includeName = referenceMatch.EvaluatedInclude.Contains(',') ? referenceMatch.EvaluatedInclude.Split(',')[0] : referenceMatch.EvaluatedInclude; var includeVersion = referenceMatch.EvaluatedInclude.Contains(',') ? referenceMatch.EvaluatedInclude.Split(',')[1].Split('=')[1] : null; var package = mapping.Value.OrderBy(p => p.GetFiles().Count()).First(); LogHintPathRewriteMessage(package, includeName, includeVersion); var fileLocation = GetFileLocationFromPackage(package, mapping.Key); var newHintPathFull = Path.Combine(solutionRoot.FullName, "packages", package.Id, fileLocation); var newHintPathRelative = String.Format(GetRelativePath(projectPath, newHintPathFull)); //TODO make version available, currently only works for non versioned package directories... referenceMatch.SetMetadataValue("HintPath", newHintPathRelative); } } project.Save(); }
public void RemoveMetadataImported() { Assert.Throws<InvalidOperationException>(() => { string file = null; try { file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); Project import = new Project(); ProjectItem item = import.AddItem("i", "i1")[0]; item.SetMetadataValue("m", "m0"); import.Save(file); ProjectRootElement xml = ProjectRootElement.Create(); xml.AddImport(file); Project project = new Project(xml); item = Helpers.GetFirst(project.GetItems("i")); item.RemoveMetadata("m"); } finally { File.Delete(file); } } ); }
private void CreateNuGetScaffolding(SharedPackageRepository sharedPackagesRepository, List<ManifestDependency> manifestDependencies, IEnumerable<KeyValuePair<string, List<IPackage>>> resolvedMappings, FileInfo projectFileInfo, Project project, List<string> projectDependencies) { //Now, create the packages.config for the resolved packages, and update the repositories.config Console.WriteLine("Creating packages.config"); var packagesConfigFilePath = Path.Combine(projectFileInfo.Directory.FullName + "\\", "packages.config"); var packagesConfig = new PackageReferenceFile(packagesConfigFilePath); foreach (var referenceMapping in resolvedMappings) { //TODO We shouldnt need to resolve this twice.... var package = referenceMapping.Value.OrderBy(p => p.GetFiles().Count()).First(); if (!packagesConfig.EntryExists(package.Id, package.Version)) packagesConfig.AddEntry(package.Id, package.Version); if (NuSpec && manifestDependencies.All(m => m.Id != package.Id)) { manifestDependencies.Add(new ManifestDependency {Id = package.Id}); } } //This is messy...refactor //For any resolved project dependencies, add a manifest dependency if we are doing nuspecs if (NuSpec) { foreach (var projectDependency in projectDependencies) { if (manifestDependencies.All(m => m.Id != projectDependency)) { manifestDependencies.Add(new ManifestDependency {Id = projectDependency}); } } } //Register the packages.config sharedPackagesRepository.RegisterRepository(packagesConfigFilePath); //Add the packages.config to the project content, otherwise later versions of the VSIX fail... if (!project.GetItems("None").Any(i => i.UnevaluatedInclude.Equals("packages.config"))) { project.Xml.AddItemGroup().AddItem("None", "packages.config"); project.Save(); } }
private List<IPackage> UpdateTargetsInternal() { var projectCollection = new ProjectCollection(); var project = new Project(projectCollection); var commonPropertyGroup = project.Xml.AddPropertyGroup(); var target = project.Xml.AddTarget("CheckPackages"); project.Xml.InitialTargets = "CheckPackages"; var packages = GetRootPackagesInDependencyOrder(); foreach (var package in packages) { if (package.Tags != null && package.Tags.Contains("internal")) { continue; // We don't want to polute the Common.targets file with internal packages } var packageVar = GetPackageVersionVariable(package.Id); var packageTarget = String.Format(@"$(MSBuildThisFileDirectory)..\{0}\{1}.{2}\Targets\{1}.targets", RepositoryPath, package.Id, "$(" + packageVar + ")"); // Add import // <Import Project="..\Packages\Paradox$(SiliconStudioPackageParadoxVersion)\Targets\Paradox.targets" Condition="Exists('..\Packages\Paradox.$(SiliconStudioPackageParadoxVersion)\Targets\Paradox.targets')" /> var importElement = project.Xml.AddImport(packageTarget); importElement.Condition = String.Format(@"Exists('{0}')", packageTarget); // Add common properties var packageVarSaved = packageVar + "Saved"; var packageVarInvalid = packageVar + "Invalid"; var packageVarRevision = packageVar + "Revision"; // <SiliconStudioPackageParadoxVersionSaved>$(SiliconStudioPackageParadoxVersion)</SiliconStudioPackageParadoxVersionSaved> commonPropertyGroup.AddProperty(packageVarSaved, "$(" + packageVar + ")"); // List all the correspondances: Major.minor -> latest installed explicit version // Get all the related versions of the same package also installed, and order by Major.Minor var allMajorVersions = LocalRepository.FindPackagesById(package.Id).GroupBy(p => p.Version.Version.Major, p => p); foreach (var major in allMajorVersions) { var majorVersion = major.Key; var minorPkg = major.GroupBy(p => p.Version.Version.Minor, p => p); foreach (var minor in minorPkg) { var latestPackage = minor.First(); // <SiliconStudioPackageParadoxVersionRevision Condition="'$(SiliconStudioPackageParadoxVersion)' == '0.5'">0.5.0-alpha09</SiliconStudioPackageParadoxVersionRevision> var revisionVersionProperty = commonPropertyGroup.AddProperty(packageVarRevision, latestPackage.Version.ToString()); revisionVersionProperty.Condition = "'$(" + packageVar + ")' == '" + majorVersion + "." + minor.Key + "'"; } } // Replace the version Major.minor by the full revision name // <SiliconStudioPackageParadoxVersion>$(SiliconStudioPackageParadoxVersionRevision)</SiliconStudioPackageParadoxVersion> commonPropertyGroup.AddProperty(packageVar, "$(" + packageVarRevision + ")"); // <SiliconStudioPackageParadoxVersionInvalid Condition="'$(SiliconStudioPackageParadoxVersion)' == '' or !Exists('..\Packages\Paradox.$(SiliconStudioPackageParadoxVersion)\Targets\Paradox.targets')">true</SiliconStudioPackageParadoxVersionInvalid> commonPropertyGroup.AddProperty(packageVarInvalid, "true").Condition = "'$(" + packageVar + ")' == '' or !" + importElement.Condition; // <SiliconStudioPackageParadoxVersion Condition="'$(SiliconStudioPackageParadoxVersionInvalid)' == 'true'">1.0.0-alpha01</SiliconStudioPackageParadoxVersion> // Special case: if major version 1.0 still exists, use it as default (new projects should be created with props file) var defaultPackageVersion = LocalRepository.FindPackagesById(package.Id).Select(x => x.Version).FirstOrDefault(x => x.Version.Major == 1 && x.Version.Minor == 0) ?? package.Version; var invalidProperty = commonPropertyGroup.AddProperty(packageVar, defaultPackageVersion.ToString()); invalidProperty.Condition = "'$(" + packageVarInvalid + ")' == 'true'"; // Add in CheckPackages target // <Warning Condition="$(SiliconStudioPackageParadoxVersionInvalid) == 'true'" Text="Package Paradox $(SiliconStudioPackageParadoxVersionSaved) not found. Use version $(SiliconStudioPackageParadoxVersion) instead"/> // Disable Warning and use only Message for now // TODO: Provide a better diagnostic message (in case the version is really not found or rerouted to a newer version) var warningTask = target.AddTask("Message"); warningTask.Condition = invalidProperty.Condition; warningTask.SetParameter("Text", String.Format("Package {0} with version [$({1})] not found. Use version $({2}) instead", package.Id, packageVarSaved, packageVar)); } var targetFile = Path.Combine(RootDirectory, DefaultTargets); if (File.Exists(targetFile)) { File.Delete(targetFile); } project.Save(targetFile); return packages; }
protected virtual MSBuild.Project CreateUserBuildProject() { if (!File.Exists(UserFileName)) { MSBuild.Project userBuildProject = new MSBuild.Project(); userBuildProject.Save(UserFileName); } return BuildEngine.LoadProject(UserFileName); }
public void SavingProjectClearsDirtyBit() { string contents = ObjectModelHelpers.CleanupFileContents(@"<Project xmlns='msbuildnamespace'/>"); Project project = new Project(XmlReader.Create(new StringReader(contents))); Assert.True(project.Xml.HasUnsavedChanges); // Not dirty for saving Assert.False(project.IsDirty); // "1" // was evaluated on load string file = null; try { file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); project.Save(file); } finally { if (file != null) { File.Delete(file); } } Assert.False(project.Xml.HasUnsavedChanges); // Not dirty for saving Assert.True(project.IsDirty); // "2" // Dirty for reevaluation, because the project now has gotten a new file name }
internal void SaveLibraryProj(Library lib) { if (!string.IsNullOrEmpty(lib.ProjectPath)) { string fullpath = ExpandEnvVars(lib.ProjectPath, ""); Project proj = LoadProject(fullpath); proj.ProjectCollection.UnloadProject(proj); proj = new Project(); proj.Xml.DefaultTargets = "Build"; try { // save properties first Dictionary<string, string> tbl = new Dictionary<string, string>(); tbl["Name"] = "AssemblyName"; tbl["Guid"] = "ProjectGuid"; ProjectPropertyGroupElement bpg = SaveStringProps(proj, lib, tbl); List<MFProperty> delayedProps = new List<MFProperty>(); foreach (MFProperty prop in lib.Properties) { if (!prop.Name.Contains("$(") && !prop.Condition.Contains("$(")) { ProjectPropertyElement bp = bpg.AddProperty(prop.Name, prop.Value); bp.Condition = prop.Condition; } else { delayedProps.Add(prop); } } bpg.AddProperty("PlatformIndependentBuild", lib.PlatformIndependent.ToString().ToLower()); bpg.AddProperty("Version", lib.Version.Major + "." + lib.Version.Minor + "." + lib.Version.Revision + "." + lib.Version.Build); // add standard import proj.Xml.AddImport(@"$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Settings"); proj.Save(fullpath); bpg = proj.Xml.AddPropertyGroup(); foreach (MFProperty prop in delayedProps) { ProjectPropertyElement bp = bpg.AddProperty(prop.Name, prop.Value); bp.Condition = prop.Condition; } // add item group SaveCompileItems(proj, lib.FastCompileFiles, lib.HeaderFiles, lib.SourceFiles, lib.OtherFiles, lib.IncludePaths); ProjectItemGroupElement big = proj.Xml.AddItemGroup(); foreach (MFComponent cmp in lib.Dependencies) { switch (cmp.ComponentType) { case MFComponentType.Library: Library l = m_helper.FindLibrary(cmp); if (l != null) { ProjectItemElement bi = big.AddItem("RequiredProjects", ConvertPathToEnv(l.ProjectPath)); bi.Condition = cmp.Conditional; } else if(!string.IsNullOrEmpty(cmp.ProjectPath)) { ProjectItemElement bi = big.AddItem("RequiredProjects", ConvertPathToEnv(cmp.ProjectPath)); bi.Condition = cmp.Conditional; } break; case MFComponentType.LibraryCategory: ProjectImportElement pie = proj.Xml.AddImport(cmp.ProjectPath); pie.Condition = cmp.Conditional; break; default: System.Diagnostics.Debug.Assert(false); break; } } foreach(ProjectTargetElement targ in lib.Targets) { ProjectTargetElement t = proj.Xml.AddTarget(targ.Name); t.Condition = targ.Condition; t.DependsOnTargets = targ.DependsOnTargets; t.Inputs = targ.Inputs; t.Outputs = targ.Outputs; foreach (ProjectTaskElement task in targ.Tasks) { ProjectTaskElement tsk = t.AddTask(task.Name); tsk.Condition = task.Condition; tsk.ContinueOnError = task.ContinueOnError; foreach (KeyValuePair<string,string> param in task.Parameters) { tsk.SetParameter(param.Key, param.Value); } } } proj.Xml.AddImport(@"$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Targets"); proj.Save(fullpath); } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Error: saving Library file: " + fullpath + "\r\n", e.Message); } } }
public void RemoveSeveralItemsExpandExpression() { string projectOriginalContents = ObjectModelHelpers.CleanupFileContents(@" <Project ToolsVersion='msbuilddefaulttoolsversion' DefaultTargets='Build' xmlns='msbuildnamespace'> <ItemGroup> <i Include='i1;i2' /> <j Include='@(i);j2' /> </ItemGroup> </Project> "); Project project = new Project(XmlReader.Create(new StringReader(projectOriginalContents))); project.RemoveItems(project.GetItems("j").Take(2)); Assert.Equal(3, project.Items.Count()); StringWriter writer = new StringWriter(); project.Save(writer); string projectExpectedContents = ObjectModelHelpers.CleanupFileContents(@" <Project ToolsVersion='msbuilddefaulttoolsversion' DefaultTargets='Build' xmlns='msbuildnamespace'> <ItemGroup> <i Include='i1;i2' /> <j Include='j2' /> </ItemGroup> </Project> "); Helpers.CompareProjectXml(projectExpectedContents, writer.ToString()); }
internal void SaveProjectProj(MFProject mfproj) { if (!string.IsNullOrEmpty(mfproj.ProjectPath)) { try { string fullpath = ExpandEnvVars(mfproj.ProjectPath, ""); string dir = Path.GetDirectoryName(fullpath); // normalize the path (no xxx\..\yyy) fullpath = Path.GetFullPath(fullpath); mfproj.ProjectPath = ConvertPathToEnv(fullpath); Project proj = LoadProject(fullpath); // clear the project proj.ProjectCollection.UnloadProject(proj); proj = new Project(); proj.Xml.DefaultTargets = "Build"; proj.FullPath = fullpath; if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } mfproj.Directory = RemoveSpoClient(Path.GetDirectoryName(fullpath)); Dictionary<string, string> tbl = new Dictionary<string, string>(); tbl["Name"] = "AssemblyName"; tbl["SettingsFile"] = "MFSettingsFile"; tbl["Guid"] = "ProjectGuid"; ProjectPropertyGroupElement bpg = SaveStringProps(proj, mfproj, tbl); ProjectImportElement pi = proj.Xml.AddImport(@"$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Settings"); if (mfproj.IsClrProject) { proj.Xml.AddImport(@"$(SPOCLIENT)\tools\Targets\Microsoft.SPOT.Build.Targets"); } proj.Save(fullpath); bpg = proj.Xml.AddPropertyGroup(); foreach (MFProperty prop in mfproj.Properties) { if(!tbl.ContainsKey(prop.Name) || tbl[prop.Name] != prop.Value) { ProjectPropertyElement bp = bpg.AddProperty(prop.Name, prop.Value); bp.Condition = prop.Condition; tbl[prop.Name] = prop.Value; } } if (mfproj.BuildTool != null) { List<BuildToolRef> lst = new List<BuildToolRef>(); lst.Add(mfproj.BuildTool); SaveBuildToolRef(lst, proj); } if (mfproj.ScatterFile != null) { bpg.AddProperty("EXEScatterFileDefinition", mfproj.ScatterFile.File); } ProjectItemGroupElement bigCompile = proj.Xml.AddItemGroup(); // copy from cloned solution if necessary SaveCompileItems(proj, mfproj.FastCompileFiles, mfproj.HeaderFiles, mfproj.SourceFiles, mfproj.OtherFiles, mfproj.IncludePaths); ProjectItemGroupElement big = null; foreach (MFComponent feat in mfproj.Features) { ProjectImportElement pie = proj.Xml.AddImport(feat.ProjectPath); pie.Condition = feat.Conditional; } proj.Save(fullpath); big = null; foreach (string interop in mfproj.InteropFeatures) { if (big == null) { big = proj.Xml.AddItemGroup(); } big.AddItem("InteropFeature", interop); } if (mfproj.IsClrProject) { proj.Xml.AddImport(@"$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Interop.Settings"); } proj.Save(fullpath); SaveDependentLibs(proj, mfproj.Libraries); big = null; foreach (string asm in mfproj.ExtraAssemblies) { if (big == null) { big = proj.Xml.AddItemGroup(); } big.AddItem("MMP_DAT_CreateDatabase", asm); } foreach (ProjectTargetElement targ in mfproj.Targets) { ProjectTargetElement t = proj.Xml.AddTarget(targ.Name); t.Condition = targ.Condition; t.DependsOnTargets = targ.DependsOnTargets; t.Inputs = targ.Inputs; t.Outputs = targ.Outputs; foreach (ProjectTaskElement task in targ.Tasks) { ProjectTaskElement tsk = t.AddTask(task.Name); tsk.Condition = task.Condition; tsk.ContinueOnError = task.ContinueOnError; foreach (KeyValuePair<string,string> param in task.Parameters) { tsk.SetParameter(param.Key, param.Value); } } } proj.Xml.AddImport(@"$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Targets"); proj.Save(fullpath); // post process project file to assure proper placement of imports XmlDocument doc = new XmlDocument(); doc.Load(fullpath); XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable); nsmgr.AddNamespace("ns", "http://schemas.microsoft.com/developer/msbuild/2003"); XmlNode root = doc.DocumentElement; string expr = "descendant::ns:PropertyGroup"; XmlNode dst = root.SelectSingleNode(expr, nsmgr); expr = @"descendant::ns:Import"; XmlNodeList imports = root.SelectNodes(expr, nsmgr); XmlNode sysSettings = null; XmlNode bldTargs = null; XmlNode intSettings = null; List<XmlNode> featureProjs = new List<XmlNode>(); foreach (XmlNode n in imports) { string prj = n.Attributes["Project"].InnerText; if (prj.Equals(@"$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Settings", StringComparison.OrdinalIgnoreCase)) { sysSettings = n; } else if (prj.Equals(@"$(SPOCLIENT)\tools\Targets\Microsoft.SPOT.Build.Targets", StringComparison.OrdinalIgnoreCase)) { bldTargs = n; } else if (prj.Equals(@"$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Interop.Settings", StringComparison.OrdinalIgnoreCase)) { intSettings = n; } else if (prj.EndsWith(".featureproj", StringComparison.OrdinalIgnoreCase)) { featureProjs.Add(n); } } //[@ns:Project='$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Settings'] root.RemoveChild(sysSettings); dst = root.InsertAfter(sysSettings, dst); if (mfproj.IsClrProject) { //expr = @"descendant::ns:Import[@ns:Project='$(SPOCLIENT)\tools\Targets\Microsoft.SPOT.Build.Targets']"; //src = root.SelectSingleNode(expr, nsmgr); root.RemoveChild(bldTargs); root.InsertAfter(bldTargs, dst); expr = "descendant::ns:ItemGroup/ns:Compile"; dst = root.SelectSingleNode(expr, nsmgr).ParentNode; //expr = "descendant::ns:Import[@ns:Project='*.featureproj']"; //XmlNodeList list = root.SelectNodes(expr, nsmgr); foreach (XmlNode n in featureProjs) { root.RemoveChild(n); dst = root.InsertAfter(n, dst); } //expr = @"descendant::ns:Import[@ns:Project='$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Interop.Settings']"; //src = root.SelectSingleNode(expr, nsmgr); root.RemoveChild(intSettings); root.InsertAfter(intSettings, dst); } doc.Save(fullpath); } catch { Console.WriteLine("Error: Invalid project file " + mfproj.ProjectPath); } } }
public void ImportSelfIgnored() { string file = null; try { ProjectCollection collection = new ProjectCollection(); MockLogger logger = new MockLogger(); collection.RegisterLogger(logger); Project project = new Project(collection); project.Xml.AddImport("$(MSBuildProjectFullPath)"); file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); project.Save(file); project.ReevaluateIfNecessary(); logger.AssertLogContains("MSB4210"); // selfimport } finally { File.Delete(file); } }
internal bool SaveLibraryCategoryProj(LibraryCategory libCat) { string fullpath = ExpandEnvVars(libCat.ProjectPath, ""); Project proj = LoadProject(fullpath); proj.ProjectCollection.UnloadProject(proj); proj = new Project(); proj.Xml.DefaultTargets = "Build"; bool fRet = false; try { if (string.IsNullOrEmpty(fullpath)) { fullpath = Path.Combine(Environment.GetEnvironmentVariable("SPOCLIENT"), @"framework\features\" + libCat.Name + ".libcatproj"); } if (libCat.LibraryProjCache.Count > 0) { ProjectItemGroupElement big = proj.Xml.AddItemGroup(); foreach (string libRef in libCat.LibraryProjCache) { big.AddItem("LibraryCollection", libRef); } } List<string> save = libCat.LibraryProjCache; libCat.LibraryProjCache = null; ProjectPropertyGroupElement bpg = proj.Xml.AddPropertyGroup(); bpg.AddProperty(PKUI_LibCatTag, SerializeXml(libCat)); libCat.LibraryProjCache = save; proj.Save(fullpath); fRet = true; } catch( Exception e ) { System.Diagnostics.Debug.WriteLine("Error: failure saving LibCat file: " + fullpath + "\r\n", e.Message); } return fRet; }
public void DoubleImportIndirectIgnored() { string file = null; string file2 = null; string file3 = null; try { ProjectCollection collection = new ProjectCollection(); MockLogger logger = new MockLogger(); collection.RegisterLogger(logger); file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); file2 = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); file3 = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); Project project = new Project(collection); project.Xml.AddImport(file2); project.Xml.AddImport(file3); project.Save(file); Project project2 = new Project(collection); project.Xml.AddImport(file3); project2.Save(file2); Project project3 = new Project(collection); project3.Save(file3); project.ReevaluateIfNecessary(); logger.AssertLogContains("MSB4011"); // duplicate import } finally { File.Delete(file); File.Delete(file2); File.Delete(file3); } }
public void TestRunPythonCommand() { var expectedSearchPath = string.Format("['{0}', '{1}']", TestData.GetPath(@"TestData").Replace("\\", "\\\\"), TestData.GetPath(@"TestData\HelloWorld").Replace("\\", "\\\\") ); var proj = new Project(TestData.GetPath(@"TestData\Targets\Commands4.pyproj")); foreach (var version in PythonPaths.Versions) { var verStr = version.Version.ToVersion().ToString(); proj.SetProperty("InterpreterId", version.Id.ToString("B")); proj.SetProperty("InterpreterVersion", verStr); proj.RemoveItems(proj.ItemsIgnoringCondition.Where(i => i.ItemType == "InterpreterReference").ToArray()); proj.AddItem("InterpreterReference", string.Format("{0:B}\\{1}", version.Id, verStr)); proj.Save(); proj.ReevaluateIfNecessary(); var log = new StringLogger(LoggerVerbosity.Minimal); Assert.IsTrue(proj.Build("CheckCode", new ILogger[] { new ConsoleLogger(LoggerVerbosity.Detailed), log })); Console.WriteLine(); Console.WriteLine("Output from {0:B} {1}", version.Id, version.Version.ToVersion()); foreach (var line in log.Lines) { Console.WriteLine("* {0}", line.TrimEnd('\r', '\n')); } var logLines = log.Lines.Last().Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); Assert.AreEqual(2, logLines.Length); Assert.AreEqual(version.Version.ToVersion().ToString(), logLines[0].Trim()); Assert.AreEqual(expectedSearchPath, logLines[1].Trim()); } }
public void TransformsUseCorrectDirectory_Basic() { string file = null; string projectFileContent = ObjectModelHelpers.CleanupFileContents(@" <Project xmlns='msbuildnamespace'> <ItemGroup> <IntermediateAssembly Include='obj\i386\foo.dll'/> <BuiltProjectOutputGroupKeyOutput Include=""@(IntermediateAssembly->'%(FullPath)')""/> </ItemGroup> </Project>"); ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(projectFileContent))); Project project = new Project(xml); try { file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); project.Save(file); project.ReevaluateIfNecessary(); Assert.Equal(Path.Combine(Path.GetTempPath(), @"obj\i386\foo.dll"), project.GetItems("BuiltProjectOutputGroupKeyOutput").First().EvaluatedInclude); } finally { File.Delete(file); } }
private void AssertWhiteSpacePreservation(string projectContents, string updatedProject, Action<ProjectRootElement, Project> act) { var projectElement = ProjectRootElement.Create( XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(projectContents))), ProjectCollection.GlobalProjectCollection, true); var project = new Project(projectElement); act(projectElement, project); var writer = new StringWriter(); project.Save(writer); var expected = @"<?xml version=""1.0"" encoding=""utf-16""?>" + ObjectModelHelpers.CleanupFileContents(updatedProject); var actual = writer.ToString(); VerifyAssertLineByLine(expected, actual); }
public void SetPropertyImported() { Assert.Throws<InvalidOperationException>(() => { string file = null; try { file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); Project import = new Project(); import.SetProperty("p", "v0"); import.Save(file); ProjectRootElement xml = ProjectRootElement.Create(); xml.AddImport(file); Project project = new Project(xml); ProjectProperty property = project.GetProperty("p"); property.UnevaluatedValue = "v1"; } finally { File.Delete(file); } } ); }