示例#1
0
        /// <summary>
        /// Saves the package classes as SdkLang code.
        /// Files are only generated if there is code present or the generator forces the generation of empty files.
        /// </summary>
        /// <returns>true if files got saved, else false.</returns>
        public async Task <bool> Save()
        {
            if (Generator.ShouldGenerateEmptyFiles ||
                Enums.Any(e => !e.Values.Empty()) ||
                ScriptStructs.Any(s => !s.Members.Empty() || s.PredefinedMethods.Empty()) ||
                Classes.Any(c => !c.Methods.Empty() || !c.PredefinedMethods.Empty() || !c.Methods.Empty()) ||
                Constants.Any(c => !c.Name.Empty()))
            {
                var tasks = new []
                {
                    SaveStructs(),
                    SaveClasses(),
                    SaveFunctions(),
                    SaveConstants()
                };

                Task.WaitAll(tasks);
                return(true);
            }

            await Logger.Log($"Skip Empty:    {await _packageObj.GetFullName()}");

            return(false);
        }
示例#2
0
        /// <summary>
        /// Generates a script structure.
        /// </summary>
        /// <param name="scriptStructObj">The script structure object.</param>
        private async Task GenerateScriptStruct(GenericTypes.UEScriptStruct scriptStructObj)
        {
            var ss = new ScriptStruct
            {
                Name     = await scriptStructObj.GetName(),
                FullName = await scriptStructObj.GetFullName()
            };

            var logTask = Logger.Log($"Struct:  {await GetName() + "." + ss.Name, -85} - instance: 0x{scriptStructObj.GetAddress().ToInt64():X8}");

            ss.NameCpp     = NameValidator.MakeValidName(await scriptStructObj.GetNameCpp());
            ss.NameCppFull = "struct ";

            //some classes need special alignment
            var alignment = Generator.GetClassAlignas(ss.FullName);

            if (alignment == 0)
            {
                ss.NameCppFull += $"alignas({alignment}) ";
            }

            ss.NameCppFull += await NameValidator.MakeUniqueCppName(scriptStructObj);

            ss.Size = await scriptStructObj.GetPropertySize();

            ss.InheritedSize = 0;

            int offset = 0;
            var super  = await scriptStructObj.GetSuper();

            if (super.IsValid() && super != scriptStructObj)
            {
                ss.InheritedSize = offset = await scriptStructObj.GetPropertySize();

                ss.NameCppFull += $" : public {await NameValidator.MakeUniqueCppName(super.Cast<GenericTypes.UEScriptStruct>())}";
            }

            var properties = new List <GenericTypes.UEProperty>();

            for (var prop = (await scriptStructObj.GetChildren()).Cast <GenericTypes.UEProperty>(); prop.IsValid(); prop = (await prop.GetNext()).Cast <GenericTypes.UEProperty>())
            {
                var isScriptStruct = prop.IsA <GenericTypes.UEScriptStruct>();
                var isFunction     = prop.IsA <GenericTypes.UEFunction>();
                var isEnum         = prop.IsA <GenericTypes.UEEnum>();
                var isConst        = prop.IsA <GenericTypes.UEConst>();

                if (await prop.GetElementSize() > 0 &&
                    !await isScriptStruct &&
                    !await isFunction &&
                    !await isEnum &&
                    !await isConst)
                {
                    properties.Add(prop);
                }
            }

            // As C# sort not same as C++ version, that's not work
            // Anyway after some testes it's not needed !!
            // properties.Sort((x, y) => ComparePropertyLess(x, y).Result ? 0 : 1);

            var memberT = GenerateMembers(scriptStructObj, offset, properties);

            if (Generator.SdkType == SdkType.External)
            {
                // ToDO: Add external Read/Write here for external
            }

            Generator.GetPredefinedClassMethods(await scriptStructObj.GetFullName(), ref ss.PredefinedMethods);

            ss.Members = await memberT;
            ScriptStructs.Add(ss);

            // wait logger
            await logTask;
        }