/// <summary> /// Builds the game using Volt Builder's <see cref="GameBuilder.BuildGame"/> /// </summary> public static void StartVoltBuilder() { Debug.Log("Build game started..."); System.Console.WriteLine("Build game started..."); ParseCommandLineArguments(out Dictionary <string, string> arguments); if (!arguments.ContainsKey("buildTarget")) { EditorApplication.Exit(-1); } bool currentZipBuild = false; if (SettingsManager.Instance.ContainsKey <bool>(ZipBuildKey)) { currentZipBuild = SettingsManager.Instance.Get <bool>(ZipBuildKey); } SettingsManager.Instance.Set(ZipBuildKey, true); BuildTarget target = (BuildTarget)Enum.Parse(typeof(BuildTarget), arguments["buildTarget"]); string buildDir = $"{GameBuilder.GetBuildDirectory()}{target}-DevOpsBuild/{PlayerSettings.productName}"; System.Console.WriteLine($"Building TC for {target} platform to {buildDir}"); GameBuildOptions options = new GameBuildOptions(buildDir, target, BuildActions.GetBuildActions()); AddressablesBuilder.BuildAddressables(); GameBuilder.BuildGame(options); SettingsManager.Instance.Set(ZipBuildKey, currentZipBuild); }
private InstallationComponent RemoveExistingBuilds() { return(new InstallationComponent("Removing any existing builds", OtherActions.DoNothing(), BuildActions.DeleteAllBuilds(), OtherActions.DoNothing())); }
public bool Build(Project project, bool runOutput) { ipcName = Globals.MainForm.ProcessArgString("$(BuildIPC)"); string compiler = null; if (project.NoOutput) { // get the compiler for as3 projects, or else the FDBuildCommand pre/post command in FDBuild will fail on "No Output" projects if (project.Language == "as3") { compiler = ProjectManager.Actions.BuildActions.GetCompilerPath(project); } if (project.PreBuildEvent.Trim().Length == 0 && project.PostBuildEvent.Trim().Length == 0) { // no output and no build commands if (project is AS2Project || project is AS3Project) { //RunFlashIDE(runOutput); //ErrorManager.ShowInfo(TextHelper.GetString("ProjectManager.Info.NoOutputAndNoBuild")); } else { //ErrorManager.ShowInfo("Info.InvalidProject"); ErrorManager.ShowInfo(TextHelper.GetString("ProjectManager.Info.NoOutputAndNoBuild")); } return(false); } } else { // Ask the project to validate itself string error; project.ValidateBuild(out error); if (error != null) { ErrorManager.ShowInfo(TextHelper.GetString(error)); return(false); } // 出力先が空だったとき if (project.OutputPath.Length < 1) { ErrorManager.ShowInfo(TextHelper.GetString("ProjectManager.Info.SpecifyValidOutputSWF")); return(false); } compiler = BuildActions.GetCompilerPath(project); if (compiler == null || (!Directory.Exists(compiler) && !File.Exists(compiler))) { string info = TextHelper.GetString("ProjectManager.Info.InvalidCustomCompiler"); MessageBox.Show(info, TextHelper.GetString("ProjectManager.Title.ConfigurationRequired"), MessageBoxButtons.OK); return(false); } } return(FDBuild(project, runOutput, compiler)); }
public GlobalJsonResult <Build> UpdateBuild([FromBody] UpdateBuildRequest request) { var build = request.Map(); dataAccessDispatcher.Dispatch(BuildActions.UpdateBuild(build)); return(GlobalJsonResult <Build> .Success(System.Net.HttpStatusCode.OK, build)); }
public void AddBuildAction(BuildAction action) { if (action == null) { throw new ArgumentNullException(nameof(action)); } BuildActions.Enqueue(action); }
public void OnGUI() { //Main title EditorGUILayout.Space(2f); EditorGUILayout.LabelField("Volt Unity Builder", GUIStyles.TitleStyle); EditorGUILayout.Space(15f); BuildSettings.DrawOptions(); BuildActions.DrawOptions(); GameBuilder.DrawOptions(); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var actions = new BuildActions(); var array = (JArray)JContainer.ReadFrom(reader); foreach (JProperty item in array.Where(x => x.HasValues && x.First != null).Select(x => x.First)) { actions[item.Name] = serializer.Deserialize(item.Value.CreateReader()); } return actions; }
private static string GetActionName(BuildActions buildAction) { switch (buildAction) { case BuildActions.BuildActionRebuildAll: return(Resources.BuildActionRebuildAll); case BuildActions.BuildActionBuild: return(Resources.BuildActionBuild); case BuildActions.BuildActionClean: return(Resources.BuildActionClean); default: throw new ArgumentOutOfRangeException(nameof(buildAction)); } }
private static string GetBuildActionResourceKey(BuildActions buildAction) { switch (buildAction) { case BuildActions.BuildActionBuild: return("Build"); case BuildActions.BuildActionRebuildAll: return("Rebuild"); case BuildActions.BuildActionClean: return("Clean"); case BuildActions.BuildActionDeploy: throw new InvalidOperationException(); default: throw new ArgumentOutOfRangeException(nameof(buildAction)); } }
public BuildEventDialog(Project project) { InitializeComponent(); InitializeLocalization(); this.FormGuid = "ada69d37-2ec0-4484-b113-72bfeab2f239"; this.Font = PluginCore.PluginBase.Settings.DefaultFont; this.project = project; this.vars = new BuildEventVars(project); // this operation requires a message to ASCompletion so we don't add it to the BuildEventVars string path = BuildActions.GetCompilerPath(project); if (File.Exists(path)) { path = Path.GetDirectoryName(path); } vars.AddVar("CompilerPath", path); foreach (BuildEventInfo info in vars.GetVars()) { Add(info); } }
/// <summary> /// Adds a method to use to build the object. /// </summary> /// <param name="action">The action.</param> public IFixtureBuilder <TFixture> AddMethod(Modify <TFixture> action) { BuildActions.Add(action); return(this); }
private void Awake() { active = this; }
public void Initialize() { MainFormRef = MainForm; // Mika: added Icons.Initialize(MainForm); Settings.Initialize(MainForm); PluginData.Load(); showProjectClasspaths = Settings.ShowProjectClasspaths; showGlobalClasspaths = Settings.ShowGlobalClasspaths; MainForm.IgnoredKeys.Add(Keys.F5); MainForm.IgnoredKeys.Add(Keys.F8); #region Actions and Event Listeners menus = new FDMenus(MainForm); menus.View.Click += new EventHandler(OpenPanel); menus.GlobalClasspaths.Click += new EventHandler(OpenGlobalClasspaths); menus.ProjectMenu.NewProject.Click += new EventHandler(NewProject); menus.ProjectMenu.OpenProject.Click += new EventHandler(OpenProject); menus.ProjectMenu.CloseProject.Click += new EventHandler(CloseProject); menus.ProjectMenu.TestMovie.Click += new EventHandler(TestMovie); menus.ProjectMenu.BuildProject.Click += new EventHandler(BuildProject); menus.ProjectMenu.Properties.Click += new EventHandler(OpenProjectProperties); menus.RecentComboBox.RequestProject += new ProjectRequestHandler(GetProject); menus.RecentComboBox.OpenProject += new ProjectOpenHandler(OpenProjectSilent); buildActions = new BuildActions(MainForm); buildActions.BuildComplete += new BuildCompleteHandler(BuildComplete); buildActions.ClasspathsChanged += new EventHandler(ProjectClasspathsChanged); flashDevelopActions = new FlashDevelopActions(MainForm); fileActions = new FileActions(pluginUI); fileActions.OpenFile += new FileNameHandler(OpenFile); fileActions.FileDeleted += new FileNameHandler(FileDeleted); fileActions.FileMoved += new FileMovedHandler(FileMoved); projectActions = new ProjectActions(pluginUI); // create our UI surface and a docking panel for it pluginUI = new PluginUI(this, menus, fileActions, projectActions); pluginUI.NewProject += new EventHandler(NewProject); pluginUI.OpenProject += new EventHandler(OpenProject); pluginUI.Rename += new RenameEventHandler(fileActions.Rename); pluginUI.Tree.MovePath += new DragPathEventHandler(fileActions.Move); pluginUI.Tree.CopyPath += new DragPathEventHandler(fileActions.Copy); pluginUI.Menu.Open.Click += new EventHandler(TreeOpenItems); pluginUI.Menu.Execute.Click += new EventHandler(TreeExecuteItems); pluginUI.Menu.Insert.Click += new EventHandler(TreeInsertItem); pluginUI.Menu.AddLibrary.Click += new EventHandler(TreeAddLibraryItems); pluginUI.Menu.AlwaysCompile.Click += new EventHandler(TreeAlwaysCompileItems); pluginUI.Menu.Cut.Click += new EventHandler(TreeCutItems); pluginUI.Menu.Copy.Click += new EventHandler(TreeCopyItems); pluginUI.Menu.Paste.Click += new EventHandler(TreePasteItems); pluginUI.Menu.Delete.Click += new EventHandler(TreeDeleteItems); pluginUI.Menu.LibraryOptions.Click += new EventHandler(TreeLibraryOptions); pluginUI.Menu.Hide.Click += new EventHandler(TreeHideItems); pluginUI.Menu.ShowHidden.Click += new EventHandler(ToggleShowHidden); pluginUI.Menu.AddNewClass.Click += new EventHandler(TreeAddNewClass); pluginUI.Menu.AddNewXml.Click += new EventHandler(TreeAddXml); pluginUI.Menu.AddNewFile.Click += new EventHandler(TreeAddFile); pluginUI.Menu.AddNewFolder.Click += new EventHandler(TreeAddFolder); pluginUI.Menu.AddLibraryAsset.Click += new EventHandler(TreeAddAsset); pluginUI.Menu.AddExistingFile.Click += new EventHandler(TreeAddExistingFile); pluginUI.TreeBar.Refresh.Click += new EventHandler(TreeRefreshNode); menus.RecentComboBox.Rebuild(); #endregion pluginPanel = MainForm.CreateDockingPanel(pluginUI, Guid, Icons.Project.Img, DockState.DockRight); // try to open the last opened project string lastProject = Settings.LastProject; if (Settings.LastProject != "" && File.Exists(Settings.LastProject)) { OpenProjectSilent(lastProject); // if we open the last project right away, we need to give ASCompletion // some time before we can trust that it received our classpaths ok startupTimer = new Timer(); startupTimer.Tick += new EventHandler(ProjectClasspathsChanged); startupTimer.Interval = 1000; startupTimer.Start(); } else { Project = null; } try { ProjectIcon.Associate(); // make sure .fdp points to this instance of FD } catch (UnauthorizedAccessException) { // silent } catch (Exception) { // silent? } }
static bool BuildCodeSnippetsTxt(string SamplesDir, BuildActions Actions) { if ((Actions & BuildActions.Clean) != 0) { APISnippets.CleanAllFiles(); } if ((Actions & BuildActions.Build) == 0) { return true; } //We should be able to trim this down further. DirectoryInfo Dir = new DirectoryInfo(SamplesDir); List<string> Files = new List<string>(); foreach (string FileName in Directory.GetFiles(SamplesDir, "*.cpp", SearchOption.AllDirectories)) { if (!FileName.EndsWith(".generated.cpp")) { Files.Add(FileName); } } foreach (string FileName in Directory.GetFiles(SamplesDir, "*.h", SearchOption.AllDirectories)) { if (!FileName.EndsWith(".generated.h")) { Files.Add(FileName); } } //Do the harvesting work. { const string OpeningTag = "///CODE_SNIPPET_START:"; const string ClosingTag = "///CODE_SNIPPET_END"; APISnippets Snippets = new APISnippets(); List<string> CurrentSnippetPageNames = new List<string>(4); //Probably won't have a snippet that is shared by more than four different pages. string CurrentLine; char[] WhiteSpace = {' ', '\t'}; //Doubles as our token delimiter in one place - noted in comments. bool IsSnippetBeingProcessed = false; bool WasPreviousLineBlank = false; //Two blank lines in a row will end a code block. Don't allow this to happen in a single snippet. foreach (string FileName in Files) { // Read the file and display it line by line. System.IO.StreamReader file = new System.IO.StreamReader(FileName); while ((CurrentLine = file.ReadLine()) != null) { CurrentLine = CurrentLine.TrimStart(WhiteSpace); if (!CurrentLine.StartsWith(OpeningTag)) { continue; } CurrentSnippetPageNames = CurrentLine.Split(WhiteSpace).ToList<string>(); //Whitespace is used to delimit our API/snippet page names here. CurrentSnippetPageNames.RemoveAt(0); //Remove the opening tag, which is always in position 0 after empties have been cleared out. CurrentSnippetPageNames.RemoveAll(entry => (entry.Length < 1)); //Blank entries can show up in the list. Remove them. if (CurrentSnippetPageNames.Count < 1) { Console.WriteLine("Warning: OpeningTag for snippet harvesting found without any API pages specified."); continue; } IsSnippetBeingProcessed = true; foreach (string CurrentSnippetPageName in CurrentSnippetPageNames) { Snippets.AddSnippet(CurrentSnippetPageName); } while ((CurrentLine = file.ReadLine()) != null) { string TrimmedLine = CurrentLine.TrimStart(WhiteSpace); //This is actually a C# same-line whitespace check, not our token delimiters. if (TrimmedLine.StartsWith(OpeningTag)) { //Snippets do not currently support overlapping. If they did, closing tags should be explicit about which entries are ending, and we'd need to skip lines with opening tags. Console.WriteLine("Error: Nested OpeningTag found! This is not supported. Snippet harvesting process will fail."); return false; } else if (TrimmedLine.StartsWith(ClosingTag)) { //We're done with this snippet now. Mark that we can end cleanly. IsSnippetBeingProcessed = false; break; } if (CurrentLine.Trim().Length < 1) { if (WasPreviousLineBlank) { //Two (or more) blank lines in a row! Not permitted. continue; } else { WasPreviousLineBlank = true; } } else { WasPreviousLineBlank = false; } //This line should be added to the snippet(s) named in the "CODE_SNIPPET_START" line. Capture it. We need to add our own newline. foreach (string CurrentSnippetPageName in CurrentSnippetPageNames) { if (!Snippets.AddSnippetText(CurrentSnippetPageName, CurrentLine + Environment.NewLine)) { Console.WriteLine("Error adding text to snippet for " + CurrentSnippetPageName); return false; } } } } //If we hit the end of the file while harvesting a snippet, we should fail or have a warning. We could also just ignore the failure to end cleanly and just store the text as-is. //Opting for outright failure at the moment so that these errors don't go unnoticed. if (IsSnippetBeingProcessed) { Console.WriteLine("Code snippet start tag not matched with code snippet end tag in " + FileName); return false; } file.Close(); } if (!Snippets.WriteSnippetsToFiles()) { Console.WriteLine("Error writing intermediate snippet files."); return false; } } //Completed without error. return true; }
static bool BuildCodeUdn(string EngineDir, string XmlDir, string UdnDir, string SitemapDir, string MetadataPath, string ArchivePath, string SitemapArchivePath, List<string> Filters, BuildActions Actions) { string ApiDir = Path.Combine(UdnDir, "API"); if((Actions & BuildActions.Clean) != 0) { Console.WriteLine("Cleaning '{0}'", ApiDir); Utility.SafeDeleteDirectoryContents(ApiDir, true); Utility.SafeDeleteDirectoryContents(SitemapDir, true); } if ((Actions & BuildActions.Build) != 0) { Directory.CreateDirectory(ApiDir); Directory.CreateDirectory(SitemapDir); // Read the metadata MetadataLookup.Load(MetadataPath); // Read the list of modules List<string> InputModules = new List<string>(File.ReadAllLines(Path.Combine(XmlDir, "modules.txt"))); // Build the doxygen modules List<DoxygenModule> Modules = new List<DoxygenModule>(); foreach (string InputModule in InputModules) { Modules.Add(new DoxygenModule(Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(InputModule)), Path.GetDirectoryName(InputModule))); } // Find all the entities if (!bIndexOnly) { Console.WriteLine("Reading Doxygen output..."); // Read the engine module and split it into smaller modules DoxygenModule RootModule = DoxygenModule.Read("UE4", EngineDir, Path.Combine(XmlDir, "xml")); foreach (DoxygenEntity Entity in RootModule.Entities) { DoxygenModule Module = Modules.Find(x => Entity.File.StartsWith(x.BaseSrcDir)); Entity.Module = Module; Module.Entities.Add(Entity); } // Now filter all the entities in each module if (Filters != null && Filters.Count > 0) { FilterEntities(Modules, Filters); } // Remove all the empty modules Modules.RemoveAll(x => x.Entities.Count == 0); } // Create the index page, and all the pages below it APIIndex Index = new APIIndex(Modules); // Build a list of pages to output List<APIPage> OutputPages = new List<APIPage>(Index.GatherPages().OrderBy(x => x.LinkPath)); // Remove any pages that don't want to be written int NumRemoved = OutputPages.RemoveAll(x => !x.ShouldOutputPage()); Console.WriteLine("Removed {0} pages", NumRemoved); // Dump the output stats string StatsPath = Path.Combine(SitemapDir, "Stats.txt"); Console.WriteLine("Writing stats to '" + StatsPath + "'"); Stats NewStats = new Stats(OutputPages.OfType<APIMember>()); NewStats.Write(StatsPath); // Setup the output directory Utility.SafeCreateDirectory(UdnDir); // Build the manifest Console.WriteLine("Writing manifest..."); UdnManifest Manifest = new UdnManifest(Index); Manifest.PrintConflicts(); Manifest.Write(Path.Combine(UdnDir, APIFolder + "\\API.manifest")); // Write all the pages using (Tracker UdnTracker = new Tracker("Writing UDN pages...", OutputPages.Count)) { foreach (int Idx in UdnTracker.Indices) { APIPage Page = OutputPages[Idx]; // Create the output directory string MemberDirectory = Path.Combine(UdnDir, Page.LinkPath); if (!Directory.Exists(MemberDirectory)) { Directory.CreateDirectory(MemberDirectory); } // Write the page Page.WritePage(Manifest, Path.Combine(MemberDirectory, "index.INT.udn")); } } // Write the sitemap contents Console.WriteLine("Writing sitemap contents..."); Index.WriteSitemapContents(Path.Combine(SitemapDir, "API.hhc")); // Write the sitemap index Console.WriteLine("Writing sitemap index..."); Index.WriteSitemapIndex(Path.Combine(SitemapDir, "API.hhk")); } if ((Actions & BuildActions.Archive) != 0) { Console.WriteLine("Creating archive '{0}'", ArchivePath); Utility.CreateTgzFromDir(ArchivePath, ApiDir); Console.WriteLine("Creating archive '{0}'", SitemapArchivePath); Utility.CreateTgzFromDir(SitemapArchivePath, SitemapDir); } return true; }
static bool BuildCodeTargetInfo(string TargetInfoPath, string EngineDir, string ArchivePath, BuildActions Actions) { if ((Actions & BuildActions.Clean) != 0) { Console.WriteLine("Cleaning '{0}'", TargetInfoPath); Utility.SafeDeleteFile(TargetInfoPath); } if ((Actions & BuildActions.Build) != 0) { Console.WriteLine("Building target info..."); Utility.SafeCreateDirectory(Path.GetDirectoryName(TargetInfoPath)); string Arguments = String.Format("DocumentationEditor Win64 Debug -ignorejunk -noxge -project=\"{0}\"", Path.Combine(EngineDir, "Documentation\\Extras\\API\\Build\\Documentation.uproject")); if (!RunUnrealBuildTool(EngineDir, Arguments + " -clean")) { return false; } foreach (FileInfo Info in new DirectoryInfo(Path.Combine(EngineDir, "Intermediate\\Build")).EnumerateFiles("UBTEXport*.xml")) { File.Delete(Info.FullName); } if (!RunUnrealBuildTool(EngineDir, Arguments + " -disableunity -xgeexport")) { return false; } // Handle different versions of DocumentationEditor on the build system. if (File.Exists(Path.Combine(EngineDir, "Intermediate\\Build\\UBTExport.0.xge.xml"))) { File.Copy(Path.Combine(EngineDir, "Intermediate\\Build\\UBTExport.0.xge.xml"), TargetInfoPath, true); } else if (File.Exists(Path.Combine(EngineDir, "Intermediate\\Build\\UBTExport.000.xge.xml"))) { File.Copy(Path.Combine(EngineDir, "Intermediate\\Build\\UBTExport.000.xge.xml"), TargetInfoPath, true); } else { Console.WriteLine("Failed to find either UBTExport.0.xge.xml or UBTExport.000.xge.xml under %s", Path.Combine(EngineDir, "Intermediate\\Build\\")); return false; } } if ((Actions & BuildActions.Archive) != 0) { Console.WriteLine("Creating archive '{0}'", ArchivePath); Utility.CreateTgzFromDir(ArchivePath, Path.GetDirectoryName(TargetInfoPath)); } return true; }
static bool BuildHtml(string EngineDir, string DocToolPath, string HtmlDir, string HtmlSuffix, string ArchivePath, BuildActions Actions) { string HtmlSubDir = Path.Combine(HtmlDir, "INT", HtmlSuffix); if((Actions & BuildActions.Clean) != 0) { Console.WriteLine("Cleaning '{0}'", HtmlSubDir); Utility.SafeDeleteDirectoryContents(HtmlSubDir, true); } if ((Actions & BuildActions.Build) != 0) { Utility.SafeCreateDirectory(HtmlSubDir); using (Process DocToolProcess = new Process()) { DocToolProcess.StartInfo.WorkingDirectory = EngineDir; DocToolProcess.StartInfo.FileName = DocToolPath; DocToolProcess.StartInfo.Arguments = Path.Combine(HtmlSuffix, "*") + " -lang=INT -t=DefaultAPI.html -v=warn"; DocToolProcess.StartInfo.UseShellExecute = false; DocToolProcess.StartInfo.RedirectStandardOutput = true; DocToolProcess.StartInfo.RedirectStandardError = true; DocToolProcess.OutputDataReceived += new DataReceivedEventHandler(ProcessOutputReceived); DocToolProcess.ErrorDataReceived += new DataReceivedEventHandler(ProcessOutputReceived); try { DocToolProcess.Start(); DocToolProcess.BeginOutputReadLine(); DocToolProcess.BeginErrorReadLine(); DocToolProcess.WaitForExit(); } catch (Exception Ex) { Console.WriteLine(Ex.ToString() + "\n" + Ex.StackTrace); return false; } if (DocToolProcess.ExitCode != 0) { return false; } } } if ((Actions & BuildActions.Archive) != 0) { Console.WriteLine("Creating archive '{0}'", ArchivePath); List<string> InputFiles = new List<string>(); Utility.FindFilesForTar(HtmlDir, "Include", InputFiles, true); Utility.FindFilesForTar(HtmlDir, "INT\\" + HtmlSuffix, InputFiles, true); Utility.FindFilesForTar(HtmlDir, "Images", InputFiles, false); Utility.CreateTgzFromFiles(ArchivePath, HtmlDir, InputFiles); } return true; }
public GlobalJsonResult <IEnumerable <Build> > GetBuilds() { var result = dataAccessDispatcher.Dispatch(BuildActions.GetAllBuilds()); return(GlobalJsonResult <IEnumerable <Build> > .Success(System.Net.HttpStatusCode.OK, result)); }
public GlobalJsonResult <Build> GetBuild(string id) { var result = dataAccessDispatcher.Dispatch(BuildActions.GetBuild(id)); return(GlobalJsonResult <Build> .Success(System.Net.HttpStatusCode.OK, result)); }
/* * /// <summary> * /// Tworzy instancję obiektu * /// </summary> * public ProjectItem() * { * } * * Przykłady użycia * * implement INotifyPropertyChanged * implement INotifyPropertyChanged_Passive * implement ToString ##Name## ##SubItems## ##BuildAction## * implement ToString Name=##Name##, SubItems=##SubItems##, BuildAction=##BuildAction## * implement equals Name, SubItems, BuildAction * implement equals * * implement equals *, ~exclude1, ~exclude2 */ #region Constructors /// <summary> /// Tworzy instancję obiektu /// <param name="Name"></param> /// <param name="BuildAction"></param> /// </summary> public ProjectItem(string Name, BuildActions BuildAction) { this.Name = Name; this.BuildAction = BuildAction; }
public static void BuildGame(string buildDir, BuildTarget buildTarget, bool headLessBuild, bool devBuild = false, bool autoConnectProfiler = false, bool deepProfiling = false, bool scriptDebugging = false, bool copyPdbFiles = false, bool scriptsOnly = false) { Debug.Log($"Starting game build at {DateTime.Now:G}..."); Stopwatch stopwatch = Stopwatch.StartNew(); if (buildTarget == BuildTarget.StandaloneWindows || buildTarget == BuildTarget.StandaloneWindows64) { buildDir += ".exe"; } Debug.Log($"Building to '{buildDir}'..."); //Set target group #region Target Group BuildTargetGroup targetGroup; switch (buildTarget) { case BuildTarget.StandaloneLinux64: case BuildTarget.StandaloneWindows64: case BuildTarget.StandaloneOSX: case BuildTarget.StandaloneWindows: targetGroup = BuildTargetGroup.Standalone; break; case BuildTarget.iOS: targetGroup = BuildTargetGroup.iOS; break; case BuildTarget.Android: targetGroup = BuildTargetGroup.Android; break; case BuildTarget.WebGL: targetGroup = BuildTargetGroup.WebGL; break; case BuildTarget.WSAPlayer: targetGroup = BuildTargetGroup.WSA; break; case BuildTarget.PS4: targetGroup = BuildTargetGroup.PS4; break; case BuildTarget.XboxOne: targetGroup = BuildTargetGroup.XboxOne; break; case BuildTarget.tvOS: targetGroup = BuildTargetGroup.tvOS; break; case BuildTarget.Switch: targetGroup = BuildTargetGroup.Switch; break; case BuildTarget.Lumin: targetGroup = BuildTargetGroup.Lumin; break; case BuildTarget.Stadia: targetGroup = BuildTargetGroup.Stadia; break; case BuildTarget.CloudRendering: targetGroup = BuildTargetGroup.CloudRendering; break; default: throw new ArgumentOutOfRangeException(); } #endregion //Setup build options BuildOptions options = BuildOptions.None; //Server/Headless mode if (headLessBuild) { options |= BuildOptions.EnableHeadlessMode; } //Copy PDB files string existingCopyPdbFilesOptions = EditorUserBuildSettings.GetPlatformSettings("Standalone", CopyPdbFilesEditorString); if (copyPdbFiles) { EditorUserBuildSettings.SetPlatformSettings("Standalone", CopyPdbFilesEditorString, SettingsManager.CopyPdbFiles ? "true" : "false"); } //Dev build if (devBuild) { options |= BuildOptions.Development; if (autoConnectProfiler) { options |= BuildOptions.ConnectWithProfiler; } if (deepProfiling) { options |= BuildOptions.EnableDeepProfilingSupport; } if (scriptDebugging) { options |= BuildOptions.AllowDebugging; } } //Scripts only if (scriptsOnly) { options |= BuildOptions.BuildScriptsOnly; } //Run build action pre-build Debug.Log("Running build actions pre build..."); try { BuildActions.RunPreActions(Path.GetDirectoryName(buildDir), buildTarget, ref options); } catch (Exception ex) { Debug.LogError($"An error occurred while running a build action's pre build! {ex}"); } Debug.Log("Build actions pre build done!"); Debug.Log("Building player..."); //Build the player BuildReport report = BuildPipeline.BuildPlayer(new BuildPlayerOptions { locationPathName = buildDir, target = buildTarget, options = options, targetGroup = targetGroup, scenes = EditorBuildSettings.scenes.Select(scene => scene.path).ToArray() }); //Set CopyPDBFiles to it's original setting EditorUserBuildSettings.SetPlatformSettings("Standalone", CopyPdbFilesEditorString, existingCopyPdbFilesOptions); //If the build failed if (report.summary.result != BuildResult.Succeeded) { stopwatch.Stop(); Debug.LogError($"Build failed for some reason! Completed in {stopwatch.ElapsedMilliseconds / 1000}s."); return; } //Run Build Action post build try { BuildActions.RunPostActions(Path.GetDirectoryName(buildDir), report); } catch (Exception ex) { Debug.LogError($"An error occurred while running a build action's post build! {ex}"); } //End stopwatch.Stop(); Debug.Log($"Build done in {stopwatch.ElapsedMilliseconds / 1000}s!"); }
static void InvokeUnitTest(ParsedProject project, PlatformTarget platformTarget, AnyUnitTestSettings settings) { if (settings == null) { throw new ArgumentNullException("settings"); } if (project == null) { throw new ArgumentNullException("project"); } var path = project.ProjectFile; var relativeProjectFile = Context.Environment.WorkingDirectory.GetRelativePath(path); // parse referenced dependencies. We assume that if you reference a unit-test dll in your project, then that project // in fact contains tests. But there are always exceptions, and thus we allow you to exclude projects as well. if (ExcludeFromUnitTests.Contains(project.Project.AssemblyName) || ExcludeFromUnitTests.Contains(project.Project.ProjectGuid) || ExcludeFromUnitTests.Contains(relativeProjectFile.ToString())) { Context.Log.Verbose(string.Format(" Skipping project {0} as it was explicitly excluded from testing.", relativeProjectFile)); return; } Context.Log.Information(string.Format("Searching for tests in {0} with platform {1}", relativeProjectFile, platformTarget)); var binDir = BuildActions.ComputeProjectBinPath(project); var testDir = ComputeProjectUnitTestPath(project); var testDll = binDir.CombineWithFilePath(ComputeTargetFile(project)); if (HasTestFramework(project, NUnit2Reference)) { Context.Log.Verbose(string.Format(" Testing with NUnit 2: {0}.", relativeProjectFile)); Context.CreateDirectory(testDir); Context.NUnit(new[] { testDll }, BuildNUnitSettings(project, settings, testDir)); } else if (HasTestFramework(project, NUnit3Reference)) { Context.Log.Verbose(string.Format(" Testing with NUnit 3: {0}.", relativeProjectFile)); Context.CreateDirectory(testDir); Context.NUnit3(new[] { testDll }, BuildNUnit3Settings(project, settings, testDir)); } else if (HasTestFramework(project, Xunit2Reference)) { Context.Log.Verbose(string.Format(" Testing with XUnit 2: {0}.", relativeProjectFile)); Context.CreateDirectory(testDir); Context.XUnit2(new[] { testDll }, BuildXUnit2Settings(project, settings, testDir)); var inputFile = testDir.CombineWithFilePath(project.Project.AssemblyName + ".xunit2.xml"); var outputFile = testDir.CombineWithFilePath(project.Project.AssemblyName + ".nunit2.xml"); Context.XmlTransform(Context.File("tools/xunit.runner.console/tools/NUnitXml.xslt"), inputFile, outputFile); } else if (HasTestFramework(project, Xunit1Reference)) { Context.Log.Verbose(string.Format(" Testing with XUnit 1: {0}.", relativeProjectFile)); Context.CreateDirectory(testDir); var xunitSettings = BuildXUnitSettings(project, settings, testDir); var xunitRunner = new FixedXUnitRunner(Context.FileSystem, Context.Environment, Context.ProcessRunner, Context.Tools); xunitRunner.Run(testDll, xunitSettings, settings.ForceX86 || project.Platform == PlatformTarget.x86); var inputFile = testDir.CombineWithFilePath(project.Project.AssemblyName + ".xunit.xml"); var outputFile = testDir.CombineWithFilePath(project.Project.AssemblyName + ".nunit2.xml"); Context.XmlTransform(Context.File("tools/xunit.runners/tools/NUnitXml.xslt"), inputFile, outputFile); } else { Context.Log.Verbose( string.Format(" Skipping project {0} as it does not reference a supported unit-testing framework.", relativeProjectFile)); } }
static bool BuildBlueprintJson(string JsonDir, string EngineDir, string EditorPath, string ArchivePath, bool bBuildMachine, BuildActions Actions) { if((Actions & BuildActions.Clean) != 0) { Console.WriteLine("Cleaning '{0}'", JsonDir); Utility.SafeDeleteDirectoryContents(JsonDir, true); } if ((Actions & BuildActions.Build) != 0) { // Create the output directory Utility.SafeCreateDirectory(JsonDir); string Arguments = "-run=GenerateBlueprintAPI -path=" + JsonDir + " -name=BlueprintAPI -stdout -FORCELOGFLUSH -CrashForUAT -unattended -AllowStdOutLogVerbosity" + (bBuildMachine? " -buildmachine" : ""); Console.WriteLine("Running: {0} {1}", EditorPath, Arguments); using (Process JsonExportProcess = new Process()) { JsonExportProcess.StartInfo.WorkingDirectory = EngineDir; JsonExportProcess.StartInfo.FileName = EditorPath; JsonExportProcess.StartInfo.Arguments = Arguments; JsonExportProcess.StartInfo.UseShellExecute = false; JsonExportProcess.StartInfo.RedirectStandardOutput = true; JsonExportProcess.StartInfo.RedirectStandardError = true; JsonExportProcess.OutputDataReceived += new DataReceivedEventHandler(ProcessOutputReceived); JsonExportProcess.ErrorDataReceived += new DataReceivedEventHandler(ProcessOutputReceived); try { JsonExportProcess.Start(); JsonExportProcess.BeginOutputReadLine(); JsonExportProcess.BeginErrorReadLine(); JsonExportProcess.WaitForExit(); if(JsonExportProcess.ExitCode != 0) { return false; } } catch (Exception Ex) { Console.WriteLine(Ex.ToString() + "\n" + Ex.StackTrace); return false; } } } if((Actions & BuildActions.Archive) != 0) { Console.WriteLine("Creating archive '{0}'", ArchivePath); Utility.CreateTgzFromDir(ArchivePath, JsonDir); } return true; }
static bool BuildCodeSnippetsTxt(string SamplesDir, BuildActions Actions) { if ((Actions & BuildActions.Clean) != 0) { APISnippets.CleanAllFiles(); } if ((Actions & BuildActions.Build) == 0) { return true; } //We should be able to trim this down further. DirectoryInfo Dir = new DirectoryInfo(SamplesDir); List<string> Files = new List<string>(); foreach (string FileName in Directory.GetFiles(SamplesDir, "*.cpp", SearchOption.AllDirectories)) { if (!FileName.EndsWith(".generated.cpp")) { Files.Add(FileName); } } foreach (string FileName in Directory.GetFiles(SamplesDir, "*.h", SearchOption.AllDirectories)) { if (!FileName.EndsWith(".generated.h")) { Files.Add(FileName); } } //Do the harvesting work. { const string OpeningTag = "///CODE_SNIPPET_START:"; const string ClosingTag = "///CODE_SNIPPET_END"; const string SeeTag = "@see"; APISnippets Snippets = new APISnippets(); List<string> CurrentSnippetPageNames = new List<string>(4); //Probably won't have a snippet that is shared by more than four different pages. List<string> SeePageNames = new List<string>(4); //More than four of these on one line will probably not happen. string CurrentLine; char[] WhiteSpace = {' ', '\t'}; //Doubles as our token delimiter in one place - noted in comments. string[] ClassMemberDelimiters = new string[2] { "::", "()" }; bool IsSnippetBeingProcessed = false; bool WasPreviousLineBlank = false; //Two blank lines in a row will end a code block. Don't allow this to happen in a single snippet. foreach (string FileName in Files) { // Read the file and display it line by line. System.IO.StreamReader file = new System.IO.StreamReader(FileName); int LineNumber = 0; while ((CurrentLine = file.ReadLine()) != null) { ++LineNumber; CurrentLine = CurrentLine.TrimStart(WhiteSpace); if (!CurrentLine.Contains(OpeningTag)) { continue; } CurrentSnippetPageNames = CurrentLine.Split(WhiteSpace, StringSplitOptions.RemoveEmptyEntries).ToList<string>(); //Whitespace is used to delimit our API/snippet page names here. while ((CurrentSnippetPageNames.Count > 0) && (!CurrentSnippetPageNames[0].Contains(OpeningTag))) { CurrentSnippetPageNames.RemoveAt(0); //Remove everything before the opening tag. } if (CurrentSnippetPageNames.Count > 0) { CurrentSnippetPageNames.RemoveAt(0); //Remove the opening tag, which is always in position 0 by this point. } if (CurrentSnippetPageNames.Count < 1) { Console.WriteLine("Error: OpeningTag for snippet harvesting found without any API pages specified."); return false; } IsSnippetBeingProcessed = true; foreach (string CurrentSnippetPageName in CurrentSnippetPageNames) { Snippets.AddSnippet(CurrentSnippetPageName); if (!Snippets.AddSnippetText(CurrentSnippetPageName, "**" + Path.GetFileName(FileName) + "** at line " + LineNumber + ":" + Environment.NewLine + Environment.NewLine)) { Console.WriteLine("Error: Failed to add header text to snippet for " + CurrentSnippetPageName + " from source file " + FileName + " at line " + LineNumber); return false; } } bool FinishSnippetAfterThisLine = false; while ((CurrentLine = file.ReadLine()) != null) { ++LineNumber; string TrimmedLine = CurrentLine.TrimStart(WhiteSpace); //This is actually a C# same-line whitespace check, not our token delimiters. string TrimmedLineLower = TrimmedLine.ToLower(); if (TrimmedLine.Contains(OpeningTag)) { //Snippets do not currently support overlapping. If they did, closing tags should be explicit about which entries are ending, and we'd need to skip lines with opening tags. Console.WriteLine("Error: Nested OpeningTag found in " + FileName + " at line " + LineNumber + "! This is not supported. Snippet harvesting process will fail."); return false; } else if (TrimmedLine.StartsWith(ClosingTag)) { //We're done with this snippet now. Mark that we can end cleanly. IsSnippetBeingProcessed = false; foreach (string CurrentSnippetPageName in CurrentSnippetPageNames) { Snippets.FinishCurrentSnippet(CurrentSnippetPageName); } break; } else if (TrimmedLine.Contains(ClosingTag)) { //We will be done this snippet once we add this line (minus the tag). FinishSnippetAfterThisLine = true; CurrentLine = CurrentLine.Replace(ClosingTag, "//"); } for (int TrimmedLineStartingIndex = TrimmedLineLower.IndexOf(SeeTag); TrimmedLineStartingIndex >= 0; TrimmedLineStartingIndex = TrimmedLineLower.Substring(TrimmedLineStartingIndex + SeeTag.Length).Contains(SeeTag) ? (TrimmedLineStartingIndex + SeeTag.Length + TrimmedLineLower.Substring(TrimmedLineStartingIndex + SeeTag.Length).IndexOf(SeeTag)) : -2) { int FirstCharacter = TrimmedLineStartingIndex + SeeTag.Length; SeePageNames = TrimmedLine.Substring(FirstCharacter).Split(WhiteSpace, StringSplitOptions.RemoveEmptyEntries).ToList<string>(); //Whitespace is used to delimit our API/snippet page names here. if (SeePageNames.Count > 0) { string SeeText = SeePageNames[0]; string[] SeeTextBreakdown = SeeText.Split(ClassMemberDelimiters, StringSplitOptions.RemoveEmptyEntries); foreach (string CurrentSnippetPageName in CurrentSnippetPageNames) { if (SeeTextBreakdown.Length == 2) { //This is considered "class::member" format. if (!Snippets.AddSeeText(CurrentSnippetPageName, "1. [](API:" + SeeText + ")" + Environment.NewLine)) { Console.WriteLine("Error: Failed to add text to snippet's \"See Also\" portion for " + CurrentSnippetPageName + " from source file " + FileName + " at line " + LineNumber); return false; } } else { if (!Snippets.AddSeeText(CurrentSnippetPageName, "1. [](" + SeeText + ")" + Environment.NewLine)) { Console.WriteLine("Error: Failed to add text to snippet's \"See Also\" portion for " + CurrentSnippetPageName + " from source file " + FileName + " at line " + LineNumber); return false; } } } } } if (CurrentLine.Trim().Length < 1) { if (WasPreviousLineBlank) { //Two (or more) blank lines in a row! Not permitted. continue; } else { WasPreviousLineBlank = true; } } else { WasPreviousLineBlank = false; } //This line should be added to the snippet(s) named in the "CODE_SNIPPET_START" line. Capture it. We need to add our own newline. foreach (string CurrentSnippetPageName in CurrentSnippetPageNames) { if (!Snippets.AddSnippetText(CurrentSnippetPageName, '\t' + CurrentLine + Environment.NewLine)) { Console.WriteLine("Error: Failed to add text to snippet for " + CurrentSnippetPageName + " from source file " + FileName + " at line " + LineNumber); return false; } } if (FinishSnippetAfterThisLine) { IsSnippetBeingProcessed = false; foreach (string CurrentSnippetPageName in CurrentSnippetPageNames) { Snippets.FinishCurrentSnippet(CurrentSnippetPageName); } break; } } } //If we hit the end of the file while harvesting a snippet, we should fail or have a warning. We could also just ignore the failure to end cleanly and just store the text as-is. //Opting for outright failure at the moment so that these errors don't go unnoticed. if (IsSnippetBeingProcessed) { Console.WriteLine("Code snippet start tag not matched with code snippet end tag in " + FileName); return false; } file.Close(); } if (!Snippets.WriteSnippetsToFiles()) { Console.WriteLine("Error writing intermediate snippet files."); return false; } } //Completed without error. return true; }
static bool BuildBlueprintUdn(string JsonDir, string UdnDir, string SitemapDir, string ArchivePath, string SitemapArchivePath, BuildActions ExecActions) { string ApiDir = Path.Combine(UdnDir, "BlueprintAPI"); if ((ExecActions & BuildActions.Clean) != 0) { Console.WriteLine("Cleaning '{0}'", ApiDir); Utility.SafeDeleteDirectoryContents(ApiDir, true); Utility.SafeDeleteDirectoryContents(SitemapDir, true); } if ((ExecActions & BuildActions.Build) != 0) { Directory.CreateDirectory(ApiDir); Directory.CreateDirectory(SitemapDir); // Read the input json file string JsonFilePath = Path.Combine(JsonDir, "BlueprintAPI.json"); var json = (Dictionary<string, object>)fastJSON.JSON.Instance.Parse(File.ReadAllText(JsonFilePath)); APICategory.LoadTooltips((Dictionary<string, object>)json["Categories"]); // TODO: This path is clearly sketchy as hell, but we'll clean it up later maybe var Actions = (Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)((Dictionary<string, object>)json["Actor"])["Palette"])["ActionSet"])["Actions"]; APICategory RootCategory = new APICategory(null, "BlueprintAPI", true); foreach (var Action in Actions) { var CategoryList = Action.Key.Split('|'); var ActionCategory = RootCategory; Debug.Assert(CategoryList.Length > 0); Debug.Assert(CategoryList[0] == "Library"); for (int CategoryIndex = 1; CategoryIndex < CategoryList.Length - 1; ++CategoryIndex) { ActionCategory = ActionCategory.GetSubCategory(CategoryList[CategoryIndex]); } ActionCategory.AddAction(new APIAction(ActionCategory, CategoryList.Last(), (Dictionary<string, object>)Action.Value)); } // Build a list of pages to output List<APIPage> OutputPages = new List<APIPage>(RootCategory.GatherPages().OrderBy(x => x.LinkPath)); // Create the output directory Utility.SafeCreateDirectory(UdnDir); Utility.SafeCreateDirectory(Path.Combine(UdnDir, APIFolder)); // Build the manifest Console.WriteLine("Writing manifest..."); UdnManifest Manifest = new UdnManifest(RootCategory); Manifest.PrintConflicts(); Manifest.Write(Path.Combine(UdnDir, BlueprintAPIFolder + "\\API.manifest")); Console.WriteLine("Categories: " + OutputPages.Count(page => page is APICategory)); Console.WriteLine("Actions: " + OutputPages.Count(page => page is APIAction)); // Write all the pages using (Tracker UdnTracker = new Tracker("Writing UDN pages...", OutputPages.Count)) { foreach (int Idx in UdnTracker.Indices) { APIPage Page = OutputPages[Idx]; // Create the output directory string MemberDirectory = Path.Combine(UdnDir, Page.LinkPath); if (!Directory.Exists(MemberDirectory)) { Directory.CreateDirectory(MemberDirectory); } // Write the page Page.WritePage(Manifest, Path.Combine(MemberDirectory, "index.INT.udn")); } } // Write the sitemap contents Console.WriteLine("Writing sitemap contents..."); RootCategory.WriteSitemapContents(Path.Combine(SitemapDir, "BlueprintAPI.hhc")); // Write the sitemap index Console.WriteLine("Writing sitemap index..."); RootCategory.WriteSitemapIndex(Path.Combine(SitemapDir, "BlueprintAPI.hhk")); } if ((ExecActions & BuildActions.Archive) != 0) { Console.WriteLine("Creating archive '{0}'", ArchivePath); Utility.CreateTgzFromDir(ArchivePath, ApiDir); Console.WriteLine("Creating archive '{0}'", SitemapArchivePath); Utility.CreateTgzFromDir(SitemapArchivePath, SitemapDir); } return true; }
static bool BuildBlueprintJson(string JsonDir, string EngineDir, string EditorPath, string ArchivePath, BuildActions Actions) { if((Actions & BuildActions.Clean) != 0) { Console.WriteLine("Cleaning '{0}'", JsonDir); Utility.SafeDeleteDirectoryContents(JsonDir, true); } if ((Actions & BuildActions.Build) != 0) { // Create the output directory Utility.SafeCreateDirectory(JsonDir); using (Process JsonExportProcess = new Process()) { JsonExportProcess.StartInfo.WorkingDirectory = EngineDir; JsonExportProcess.StartInfo.FileName = EditorPath; JsonExportProcess.StartInfo.Arguments = "-run=GenerateBlueprintAPI -path=" + JsonDir + " -name=BlueprintAPI"; JsonExportProcess.StartInfo.UseShellExecute = false; JsonExportProcess.StartInfo.RedirectStandardOutput = true; JsonExportProcess.StartInfo.RedirectStandardError = true; JsonExportProcess.OutputDataReceived += new DataReceivedEventHandler(ProcessOutputReceived); JsonExportProcess.ErrorDataReceived += new DataReceivedEventHandler(ProcessOutputReceived); try { JsonExportProcess.Start(); JsonExportProcess.BeginOutputReadLine(); JsonExportProcess.BeginErrorReadLine(); JsonExportProcess.WaitForExit(); return JsonExportProcess.ExitCode == 0; } catch (Exception Ex) { Console.WriteLine(Ex.ToString() + "\n" + Ex.StackTrace); return false; } } } if((Actions & BuildActions.Archive) != 0) { Console.WriteLine("Creating archive '{0}'", ArchivePath); Utility.CreateTgzFromDir(ArchivePath, JsonDir); } return true; }
static bool BuildChm(string ChmCompilerPath, string ChmFileName, string ContentsFileName, string IndexFileName, string BaseHtmlDir, bool bBlueprint, BuildActions Actions) { if((Actions & BuildActions.Clean) != 0) { Console.WriteLine("Cleaning '{0}'", ChmFileName); Utility.SafeDeleteFile(ChmFileName); Utility.SafeDeleteDirectory(Path.Combine(Path.GetDirectoryName(ChmFileName), Path.GetFileNameWithoutExtension(ChmFileName))); } if ((Actions & BuildActions.Build) != 0) { string ProjectFileName = (bBlueprint ? "BlueprintAPI.hhp" : "API.hhp"); Console.WriteLine("Searching for CHM input files..."); // Build a list of all the files we want to copy List<string> FilePaths = new List<string>(); List<string> DirectoryPaths = new List<string>(); Utility.FindRelativeContents(BaseHtmlDir, "Include\\*", true, FilePaths, DirectoryPaths); // Find all the HTML files if (bBlueprint) { Utility.FindRelativeContents(BaseHtmlDir, "INT\\BlueprintAPI\\*.html", true, FilePaths, DirectoryPaths); CreateChm(ChmCompilerPath, ChmFileName, "UE4 Blueprint API Documentation", "INT\\BlueprintAPI\\index.html", ContentsFileName, IndexFileName, BaseHtmlDir, FilePaths); } else { Utility.FindRelativeContents(BaseHtmlDir, "Images\\api*", false, FilePaths, DirectoryPaths); Utility.FindRelativeContents(BaseHtmlDir, "INT\\API\\*.html", true, FilePaths, DirectoryPaths); CreateChm(ChmCompilerPath, ChmFileName, "UE4 API Documentation", "INT\\API\\index.html", ContentsFileName, IndexFileName, BaseHtmlDir, FilePaths); } } return true; }
public GlobalJsonResult <EmptyResult> DeleteBuild([FromBody] DeleteBuildRequest request) { dataAccessDispatcher.Dispatch(BuildActions.DeleteBuild(request.Id)); return(GlobalJsonResult <EmptyResult> .Success(System.Net.HttpStatusCode.NoContent)); }
static bool BuildCodeMetadata(string DoxygenPath, string EngineDir, string MetadataDir, string MetadataPath, string ArchivePath, BuildActions Actions) { if((Actions & BuildActions.Clean) != 0) { Console.WriteLine("Cleaning '{0}'", MetadataDir); Utility.SafeDeleteDirectoryContents(MetadataDir, true); } if((Actions & BuildActions.Build) != 0) { string MetadataInputPath = Path.Combine(EngineDir, "Source\\Runtime\\CoreUObject\\Public\\UObject\\ObjectBase.h"); Console.WriteLine("Building metadata descriptions from '{0}'...", MetadataInputPath); DoxygenConfig Config = new DoxygenConfig("Metadata", new string[]{ MetadataInputPath }, MetadataDir); if (!Doxygen.Run(DoxygenPath, Path.Combine(EngineDir, "Source"), Config, true)) { return false; } MetadataLookup.Reset(); // Parse the xml output ParseMetadataTags(Path.Combine(MetadataDir, "xml\\namespace_u_c.xml"), MetadataLookup.ClassTags); ParseMetadataTags(Path.Combine(MetadataDir, "xml\\namespace_u_i.xml"), MetadataLookup.InterfaceTags); ParseMetadataTags(Path.Combine(MetadataDir, "xml\\namespace_u_f.xml"), MetadataLookup.FunctionTags); ParseMetadataTags(Path.Combine(MetadataDir, "xml\\namespace_u_p.xml"), MetadataLookup.PropertyTags); ParseMetadataTags(Path.Combine(MetadataDir, "xml\\namespace_u_s.xml"), MetadataLookup.StructTags); ParseMetadataTags(Path.Combine(MetadataDir, "xml\\namespace_u_m.xml"), MetadataLookup.MetaTags); // Rebuild all the reference names now that we've parsed a bunch of new tags MetadataLookup.BuildReferenceNameList(); // Write it to a summary file MetadataLookup.Save(MetadataPath); } if ((Actions & BuildActions.Archive) != 0) { Console.WriteLine("Creating archive '{0}'", ArchivePath); Utility.CreateTgzFromDir(ArchivePath, MetadataDir); } return true; }
/// <summary> /// Tworzy instancję obiektu /// <param name="name"></param> /// <param name="buildAction"></param> /// </summary> public ProjectItem(string name, BuildActions buildAction) { Name = name; BuildAction = buildAction; }
static bool BuildCodeXml(string EngineDir, string TargetInfoPath, string DoxygenPath, string XmlDir, string ArchivePath, List<string> Filters, BuildActions Actions) { if ((Actions & BuildActions.Clean) != 0) { Console.WriteLine("Cleaning '{0}'", XmlDir); Utility.SafeDeleteDirectoryContents(XmlDir, true); } if ((Actions & BuildActions.Build) != 0) { Console.WriteLine("Building XML..."); Utility.SafeCreateDirectory(XmlDir); // Read the target that we're building BuildTarget Target = new BuildTarget(Path.Combine(EngineDir, "Source"), TargetInfoPath); // Create an invariant list of exclude directories string[] InvariantExcludeDirectories = ExcludeSourceDirectories.Select(x => x.ToLowerInvariant()).ToArray(); // Get the list of folders to filter against List<string> FolderFilters = new List<string>(); if (Filters != null) { foreach (string Filter in Filters) { int Idx = Filter.IndexOf('/'); if (Idx != -1) { FolderFilters.Add("\\" + Filter.Substring(0, Idx) + "\\"); } } } // Flatten the target into a list of modules List<string> InputModules = new List<string>(); foreach (string DirectoryName in Target.DirectoryNames) { for (DirectoryInfo ModuleDirectory = new DirectoryInfo(DirectoryName); ModuleDirectory.Parent != null; ModuleDirectory = ModuleDirectory.Parent) { IEnumerator<FileInfo> ModuleFile = ModuleDirectory.EnumerateFiles("*.build.cs").GetEnumerator(); if (ModuleFile.MoveNext() && (FolderFilters.Count == 0 || FolderFilters.Any(x => ModuleFile.Current.FullName.Contains(x)))) { InputModules.AddUnique(ModuleFile.Current.FullName); break; } } } // Just use all the input modules if (!bIndexOnly) { // Set our error mode so as to not bring up the WER dialog if Doxygen crashes (which it often does) SetErrorMode(0x0007); // Create the output directory Utility.SafeCreateDirectory(XmlDir); // Build all the modules Console.WriteLine("Parsing source..."); // Build the list of definitions List<string> Definitions = new List<string>(); foreach (string Definition in Target.Definitions) { if (!Definition.StartsWith("ORIGINAL_FILE_NAME=")) { Definitions.Add(Definition.Replace("DLLIMPORT", "").Replace("DLLEXPORT", "")); } } // Build a list of input paths List<string> InputPaths = new List<string>(); foreach (string InputModule in InputModules) { foreach (string DirectoryName in Directory.EnumerateDirectories(Path.GetDirectoryName(InputModule), "*", SearchOption.AllDirectories)) { // Find the relative path from the engine directory string NormalizedDirectoryName = DirectoryName; if (NormalizedDirectoryName.StartsWith(EngineDir)) { NormalizedDirectoryName = NormalizedDirectoryName.Substring(EngineDir.Length); } if (!NormalizedDirectoryName.EndsWith("\\")) { NormalizedDirectoryName += "\\"; } // Check we can include it if (!ExcludeSourceDirectories.Any(x => NormalizedDirectoryName.Contains("\\" + x + "\\"))) { if (FolderFilters.Count == 0 || FolderFilters.Any(x => NormalizedDirectoryName.Contains(x))) { InputPaths.Add(DirectoryName); } } } } // Build the configuration for this module DoxygenConfig Config = new DoxygenConfig("UE4", InputPaths.ToArray(), XmlDir); Config.Definitions.AddRange(Definitions); Config.Definitions.AddRange(DoxygenPredefinedMacros); Config.ExpandAsDefined.AddRange(DoxygenExpandedMacros); Config.IncludePaths.AddRange(Target.IncludePaths); Config.ExcludePatterns.AddRange(ExcludeSourceDirectories.Select(x => "*/" + x + "/*")); Config.ExcludePatterns.AddRange(ExcludeSourceFiles); // Run Doxygen if (!Doxygen.Run(DoxygenPath, Path.Combine(EngineDir, "Source"), Config, true)) { Console.WriteLine(" error: Doxygen crashed. Skipping."); return false; } } // Write the modules file File.WriteAllLines(Path.Combine(XmlDir, "modules.txt"), InputModules); } if ((Actions & BuildActions.Archive) != 0) { Console.WriteLine("Creating archive '{0}'", ArchivePath); Utility.CreateTgzFromDir(ArchivePath, XmlDir); } return true; }
/* /// <summary> /// Tworzy instancję obiektu /// </summary> public ProjectItem() { } Przykłady użycia implement INotifyPropertyChanged implement INotifyPropertyChanged_Passive implement ToString ##Name## ##SubItems## ##BuildAction## implement ToString Name=##Name##, SubItems=##SubItems##, BuildAction=##BuildAction## implement equals Name, SubItems, BuildAction implement equals * implement equals *, ~exclude1, ~exclude2 */ #region Constructors /// <summary> /// Tworzy instancję obiektu /// <param name="Name"></param> /// <param name="BuildAction"></param> /// </summary> public ProjectItem(string Name, BuildActions BuildAction) { this.Name = Name; this.BuildAction = BuildAction; }