示例#1
0
        /// <summary>
        /// Compile a rules assembly for the current target
        /// </summary>
        /// <param name="ProjectFile">The project file being compiled</param>
        /// <param name="TargetName">The target being built</param>
        /// <param name="bSkipRulesCompile">Whether to skip compiling any rules assemblies</param>
        /// <param name="bUsePrecompiled">Whether to use a precompiled engine/enterprise build</param>
        /// <param name="ForeignPlugin">Foreign plugin to be compiled</param>
        /// <returns>The compiled rules assembly</returns>
        public static RulesAssembly CreateTargetRulesAssembly(FileReference ProjectFile, string TargetName, bool bSkipRulesCompile, bool bUsePrecompiled, FileReference ForeignPlugin)
        {
            RulesAssembly RulesAssembly;

            if (ProjectFile != null)
            {
                RulesAssembly = CreateProjectRulesAssembly(ProjectFile, bUsePrecompiled, bSkipRulesCompile);
            }
            else
            {
                RulesAssembly = CreateEngineRulesAssembly(bUsePrecompiled, bSkipRulesCompile);

                if (RulesAssembly.GetTargetFileName(TargetName) == null)
                {
                    // Target isn't part of the engine assembly, try the enterprise assembly
                    RulesAssembly EnterpriseRulesAssembly = CreateEnterpriseRulesAssembly(bUsePrecompiled, bSkipRulesCompile);
                    if (EnterpriseRulesAssembly != null)
                    {
                        RulesAssembly = EnterpriseRulesAssembly;
                    }
                }
            }
            if (ForeignPlugin != null)
            {
                RulesAssembly = CreatePluginRulesAssembly(ForeignPlugin, bSkipRulesCompile, RulesAssembly, true);
            }
            return(RulesAssembly);
        }
示例#2
0
        /// <summary>
        /// Gets the source file containing rules for the given target
        /// </summary>
        /// <param name="TargetName">The name of the target</param>
        /// <returns>The filename containing rules for this target, or an empty string if not found</returns>
        public FileReference GetTargetFileName(string TargetName)
        {
            FileReference TargetFile;

            if (TargetNameToTargetFile.TryGetValue(TargetName, out TargetFile))
            {
                return(TargetFile);
            }
            else
            {
                return((Parent == null) ? null : Parent.GetTargetFileName(TargetName));
            }
        }
示例#3
0
        /// <summary>
        /// Writes information about the targets in an assembly to a file
        /// </summary>
        /// <param name="ProjectFile">The project file for the targets being built</param>
        /// <param name="Assembly">The rules assembly for this target</param>
        /// <param name="OutputFile">Output file to write to</param>
        /// <param name="Arguments"></param>
        public static void WriteTargetInfo(FileReference ProjectFile, RulesAssembly Assembly, FileReference OutputFile, CommandLineArguments Arguments)
        {
            // Construct all the targets in this assembly
            List <string> TargetNames = new List <string>();

            Assembly.GetAllTargetNames(TargetNames, false);

            // Write the output file
            DirectoryReference.CreateDirectory(OutputFile.Directory);
            using (JsonWriter Writer = new JsonWriter(OutputFile))
            {
                Writer.WriteObjectStart();
                Writer.WriteArrayStart("Targets");
                foreach (string TargetName in TargetNames)
                {
                    // skip target rules that are platform extension or platform group specializations
                    string[] TargetPathSplit = TargetName.Split(new char[] { '_' }, StringSplitOptions.RemoveEmptyEntries);
                    if (TargetPathSplit.Length > 1 && (UnrealTargetPlatform.IsValidName(TargetPathSplit.Last()) || UnrealPlatformGroup.IsValidName(TargetPathSplit.Last())))
                    {
                        continue;
                    }

                    // Construct the rules object
                    TargetRules TargetRules;
                    try
                    {
                        string Architecture = UEBuildPlatform.GetBuildPlatform(BuildHostPlatform.Current.Platform).GetDefaultArchitecture(ProjectFile);
                        TargetRules = Assembly.CreateTargetRules(TargetName, BuildHostPlatform.Current.Platform, UnrealTargetConfiguration.Development, Architecture, ProjectFile, Arguments);
                    }
                    catch (Exception Ex)
                    {
                        Log.TraceWarning("Unable to construct target rules for {0}", TargetName);
                        Log.TraceVerbose(ExceptionUtils.FormatException(Ex));
                        continue;
                    }

                    // Write the target info
                    Writer.WriteObjectStart();
                    Writer.WriteValue("Name", TargetName);
                    Writer.WriteValue("Path", Assembly.GetTargetFileName(TargetName).ToString());
                    Writer.WriteValue("Type", TargetRules.Type.ToString());
                    Writer.WriteObjectEnd();
                }
                Writer.WriteArrayEnd();
                Writer.WriteObjectEnd();
            }
        }
        public static void GetTargetUWPPaths(RulesAssembly InTargetRulesAssembly, string InTargetName, TargetRules InTargetRules,
                                             out string OutEngineSourceRelativeBinaryPath, out string OutRelativeTargetPath)
        {
            OutEngineSourceRelativeBinaryPath = "";
            OutRelativeTargetPath             = "";

            string TargetFilename = InTargetRulesAssembly.GetTargetFileName(InTargetName).FullName;

            string ProjectSourceFolder = new FileInfo(TargetFilename).DirectoryName;

            string EnginePath             = Path.Combine(ProjectFileGenerator.EngineRelativePath);
            string EngineSourcePath       = Path.Combine(EnginePath, "Source");
            string RelativeTargetFilename = Utils.MakePathRelativeTo(TargetFilename, EngineSourcePath);

            if ((RelativeTargetFilename.StartsWith("..") == false) && (RelativeTargetFilename.Contains(":") == false))
            {
                // This target must be UNDER Engine/Source...
                RelativeTargetFilename = Path.Combine(EngineSourcePath, RelativeTargetFilename);
            }
            RelativeTargetFilename = RelativeTargetFilename.Replace("\\", "/");
            EnginePath             = EnginePath.Replace("\\", "/");

            Int32 LastSourceIdx = RelativeTargetFilename.LastIndexOf("Source");

            if (LastSourceIdx != -1)
            {
                RelativeTargetFilename = RelativeTargetFilename.Substring(0, LastSourceIdx);
            }
            else
            {
                RelativeTargetFilename = "";
            }

            OutRelativeTargetPath = RelativeTargetFilename;

            if (InTargetRules.bOutputToEngineBinaries)
            {
                RelativeTargetFilename = EnginePath;
            }
            OutEngineSourceRelativeBinaryPath = Path.Combine(RelativeTargetFilename, "Binaries/UWP/");
            OutEngineSourceRelativeBinaryPath = OutEngineSourceRelativeBinaryPath.Replace("\\", "/");
        }
示例#5
0
        /// <summary>
        /// Writes information about the targets in an assembly to a file
        /// </summary>
        /// <param name="ProjectFile">The project file for the targets being built</param>
        /// <param name="Assembly">The rules assembly for this target</param>
        /// <param name="OutputFile">Output file to write to</param>
        /// <param name="Arguments"></param>
        public static void WriteTargetInfo(FileReference ProjectFile, RulesAssembly Assembly, FileReference OutputFile, CommandLineArguments Arguments)
        {
            // Construct all the targets in this assembly
            List <string> TargetNames = new List <string>();

            Assembly.GetAllTargetNames(TargetNames, false);

            // Write the output file
            DirectoryReference.CreateDirectory(OutputFile.Directory);
            using (JsonWriter Writer = new JsonWriter(OutputFile))
            {
                Writer.WriteObjectStart();
                Writer.WriteArrayStart("Targets");
                foreach (string TargetName in TargetNames)
                {
                    // Construct the rules object
                    TargetRules TargetRules;
                    try
                    {
                        string Architecture = UEBuildPlatform.GetBuildPlatform(BuildHostPlatform.Current.Platform).GetDefaultArchitecture(ProjectFile);
                        TargetRules = Assembly.CreateTargetRules(TargetName, BuildHostPlatform.Current.Platform, UnrealTargetConfiguration.Development, Architecture, ProjectFile, Arguments);
                    }
                    catch (Exception Ex)
                    {
                        Log.TraceWarning("Unable to construct target rules for {0}", TargetName);
                        Log.TraceVerbose(ExceptionUtils.FormatException(Ex));
                        continue;
                    }

                    // Write the target info
                    Writer.WriteObjectStart();
                    Writer.WriteValue("Name", TargetName);
                    Writer.WriteValue("Path", Assembly.GetTargetFileName(TargetName).ToString());
                    Writer.WriteValue("Type", TargetRules.Type.ToString());
                    Writer.WriteObjectEnd();
                }
                Writer.WriteArrayEnd();
                Writer.WriteObjectEnd();
            }
        }