protected string DecompileProperties() { if (Properties == null || Properties.Count == 0) { return(UDecompilingState.Tabs + "// This object has no properties!\r\n"); } string output = String.Empty; //#if DEBUG //output += UDecompilingState.Tabs + "// Object Offset:" + UnrealMethods.FlagToString( (uint)ExportTable.SerialOffset ) + "\r\n"; //#endif for (int i = 0; i < Properties.Count; ++i) { string propOutput = Properties[i].Decompile(); // This is the first element of a static array if (i + 1 < Properties.Count && Properties[i + 1].Name == Properties[i].Name && Properties[i].ArrayIndex <= 0 && Properties[i + 1].ArrayIndex > 0) { propOutput = propOutput.Insert(Properties[i].Name.Length, "[0]"); } // FORMAT: 'DEBUG[TAB /* 0xPOSITION */] TABS propertyOutput + NEWLINE output += UDecompilingState.Tabs + #if DEBUG_POSITIONS "/*" + UnrealMethods.FlagToString((uint)Properties[i]._BeginOffset) + "*/\t" + #endif propOutput + "\r\n"; } return(output); }
protected override void InitNodes(TreeNode node) { _ParentNode = AddSectionNode(node, typeof(UStruct).Name); if (IsPureStruct()) { var sFlagsNode = AddTextNode(_ParentNode, "Struct Flags:" + UnrealMethods.FlagToString(StructFlags)); sFlagsNode.ToolTipText = UnrealMethods.FlagsListToString(UnrealMethods.FlagsToList(typeof(Flags.StructFlags), StructFlags)); } AddTextNode(_ParentNode, "Script Size:" + DataScriptSize); base.InitNodes(_ParentNode); }
protected override void InitNodes(TreeNode node) { _ParentNode = AddSectionNode(node, typeof(UState).Name); if (GetType() == typeof(UState)) { var stateFlagsNode = AddTextNode(_ParentNode, "State Flags:" + UnrealMethods.FlagToString(_StateFlags)); stateFlagsNode.ToolTipText = UnrealMethods.FlagsListToString(UnrealMethods.FlagsToList(typeof(Flags.StateFlags), _StateFlags)); } base.InitNodes(_ParentNode); }
protected virtual void InitNodes(TreeNode node) { _ParentNode = AddSectionNode(node, typeof(UObject).Name); var flagNode = AddTextNode(_ParentNode, "ObjectFlags:" + UnrealMethods.FlagToString(_ObjectFlags)); flagNode.ToolTipText = UnrealMethods.FlagsListToString( UnrealMethods.FlagsToList(typeof(Flags.ObjectFlagsLO), typeof(Flags.ObjectFlagsHO), _ObjectFlags) ); AddTextNode(_ParentNode, "Size:" + ExportTable.SerialSize); AddTextNode(_ParentNode, "Offset:" + ExportTable.SerialOffset); }
protected override void InitNodes(TreeNode node) { _ParentNode = AddSectionNode(node, typeof(UClass).Name); AddSimpleObjectNode(_ParentNode, Within, "Within", Within != null ? Within.GetImageName() : ""); var classFlagsNode = AddTextNode(_ParentNode, "Class Flags:" + UnrealMethods.FlagToString(ClassFlags)); classFlagsNode.ToolTipText = UnrealMethods.FlagsListToString( UnrealMethods.FlagsToList(typeof(Flags.ClassFlags), ClassFlags) ); base.InitNodes(_ParentNode); }
protected override void InitNodes(TreeNode node) { node.ToolTipText = FormatHeader(); _ParentNode = AddSectionNode(node, typeof(UFunction).Name); var funcFlagsNode = AddTextNode(_ParentNode, "FunctionFlags:" + UnrealMethods.FlagToString(FunctionFlags)); funcFlagsNode.ToolTipText = UnrealMethods.FlagsListToString(UnrealMethods.FlagsToList(typeof(Flags.FunctionFlags), FunctionFlags)); if (RepOffset > 0) { AddTextNode(_ParentNode, "Replication Offset:" + RepOffset); } base.InitNodes(_ParentNode); }
protected override void InitNodes(TreeNode node) { _ParentNode = AddSectionNode(node, typeof(UProperty).Name); var propertyFlagsNode = AddTextNode(_ParentNode, "Property Flags:" + UnrealMethods.FlagToString(PropertyFlags) ); propertyFlagsNode.ToolTipText = UnrealMethods.FlagsListToString(UnrealMethods.FlagsToList( typeof(Flags.PropertyFlagsLO), typeof(Flags.PropertyFlagsHO), PropertyFlags) ); if (RepOffset > 0) { AddTextNode(_ParentNode, "Replication Offset:" + RepOffset); } base.InitNodes(_ParentNode); }
public string FormatFlags() { ulong copyFlags = PropertyFlags; var output = string.Empty; if (PropertyFlags == 0) { return(FormatAccess()); } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.NeedCtorLink) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.NeedCtorLink; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditorData) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditorData; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Net) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Net; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.New) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.New; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.OnDemand) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.OnDemand; } // Decompiling of this flag is put elsewhere. if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Editable) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Editable; } if (HasPropertyFlag(Flags.PropertyFlagsLO.Component)) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Component; } if (Package.Version > 300 && (PropertyFlags & (ulong)Flags.PropertyFlagsLO.Init) != 0) { output += "init "; } /** Flags that are valid as parameters only */ if (Outer is UFunction && (PropertyFlags & (ulong)Flags.PropertyFlagsLO.Parm) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Parm; // Possible since UE3 if (Package.Version > 300) { if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Const) != 0) { output += "const "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Const; } } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.CoerceParm) != 0) { output += "coerce "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.CoerceParm; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.OptionalParm) != 0) { output += "optional "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.OptionalParm; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.OutParm) != 0) { output += "out "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.OutParm; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.SkipParm) != 0) { output += "skip "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.SkipParm; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.ReturnParm) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.ReturnParm; } // Remove implied flags from GUIComponents if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.ExportObject) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.ExportObject; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditInline) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditInline; } } else /** Not a function param. */ { output += FormatAccess(); // UE3 flags if (Package.Version > 129) { if (HasPropertyFlag(Flags.PropertyFlagsHO.PrivateWrite)) { output += "privatewrite "; copyFlags &= ~(ulong)Flags.PropertyFlagsHO.PrivateWrite << 32; } if (HasPropertyFlag(Flags.PropertyFlagsHO.ProtectedWrite)) { output += "protectedwrite "; copyFlags &= ~(ulong)Flags.PropertyFlagsHO.ProtectedWrite << 32; } if (HasPropertyFlag(Flags.PropertyFlagsHO.RepNotify)) { output += "repnotify "; copyFlags &= ~(ulong)Flags.PropertyFlagsHO.RepNotify << 32; } if (HasPropertyFlag(Flags.PropertyFlagsLO.NoClear)) { output += "noclear "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.NoClear; } if (HasPropertyFlag(Flags.PropertyFlagsLO.NoImport)) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.NoImport; output += "noimport "; } if (HasPropertyFlag(Flags.PropertyFlagsLO.DataBinding)) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.DataBinding; output += "databinding "; } if (HasPropertyFlag(Flags.PropertyFlagsHO.EditHide)) { copyFlags &= ~(ulong)Flags.PropertyFlagsHO.EditHide << 32; output += "edithide "; } if (HasPropertyFlag(Flags.PropertyFlagsHO.EditTextBox)) { copyFlags &= ~(ulong)Flags.PropertyFlagsHO.EditTextBox << 32; output += "edittextbox "; } if (HasPropertyFlag(Flags.PropertyFlagsHO.Interp)) { output += "interp "; copyFlags &= ~(ulong)Flags.PropertyFlagsHO.Interp << 32; } if (HasPropertyFlag(Flags.PropertyFlagsHO.NonTransactional)) { output += "nontransactional "; copyFlags &= ~(ulong)Flags.PropertyFlagsHO.NonTransactional << 32; } if (HasPropertyFlag(Flags.PropertyFlagsLO.DuplicateTransient)) { output += "duplicatetransient "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.DuplicateTransient; // Implies: Export, EditInline } if (HasPropertyFlag(Flags.PropertyFlagsHO.EditorOnly)) { output += "editoronly "; copyFlags &= ~(ulong)Flags.PropertyFlagsHO.EditorOnly << 32; } if (HasPropertyFlag(Flags.PropertyFlagsHO.CrossLevelPassive)) { output += "crosslevelpassive "; copyFlags &= ~(ulong)Flags.PropertyFlagsHO.CrossLevelPassive << 32; } if (HasPropertyFlag(Flags.PropertyFlagsHO.CrossLevelActive)) { output += "crosslevelactive "; copyFlags &= ~(ulong)Flags.PropertyFlagsHO.CrossLevelActive << 32; } if (HasPropertyFlag(Flags.PropertyFlagsHO.Archetype)) { output += "archetype "; copyFlags &= ~(ulong)Flags.PropertyFlagsHO.Archetype << 32; } if (HasPropertyFlag(Flags.PropertyFlagsHO.NotForConsole)) { output += "notforconsole "; copyFlags &= ~(ulong)Flags.PropertyFlagsHO.NotForConsole << 32; } if (HasPropertyFlag(Flags.PropertyFlagsHO.RepRetry)) { output += "repretry "; copyFlags &= ~(ulong)Flags.PropertyFlagsHO.RepRetry << 32; } // Instanced is only an alias for Export and EditInline. /*if( HasPropertyFlag( Flags.PropertyFlagsLO.Instanced ) ) * { * output += "instanced "; * copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Instanced; * * // Implies: Export, EditInline * }*/ if (Package.Version > 500 && HasPropertyFlag(Flags.PropertyFlagsLO.SerializeText)) { output += "serializetext "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.SerializeText; } } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Native) != 0) { output += FormatNative() + " "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Native; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Const) != 0) { output += "const "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Const; } if (Package.Version > 500) { if (HasPropertyFlag(Flags.PropertyFlagsLO.EditFixedSize)) { output += "editfixedsize "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditFixedSize; } } else { if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditConstArray) != 0) { output += "editconstarray "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditConstArray; } } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditConst) != 0) { output += "editconst "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditConst; } // Properties flagged with automated, automatically get those flags added by the compiler. if (Package.Version == 128 && (PropertyFlags & (ulong)Flags.PropertyFlagsLO.Automated) != 0) { output += "automated "; copyFlags &= ~((ulong)Flags.PropertyFlagsLO.Automated | (ulong)Flags.PropertyFlagsLO.EditInlineUse | (ulong)Flags.PropertyFlagsLO.EditInlineNotify | (ulong)Flags.PropertyFlagsLO.EditInline | (ulong)Flags.PropertyFlagsLO.NoExport | (ulong)Flags.PropertyFlagsLO.ExportObject); } else // Not Automated { if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.NoExport) != 0) { output += "noexport "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.NoExport; if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.ExportObject) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.ExportObject; } } // avoid outputing export when noexport is flagged as well! else if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.ExportObject) != 0) { if (!HasPropertyFlag(Flags.PropertyFlagsLO.DuplicateTransient)) { output += "export "; } copyFlags &= ~(ulong)Flags.PropertyFlagsLO.ExportObject; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditInline) != 0) { if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditInlineUse) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditInlineUse; output += "editinlineuse "; } else if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EditInlineNotify) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditInlineNotify; output += "editinlinenotify "; } else if (!HasPropertyFlag(Flags.PropertyFlagsLO.DuplicateTransient)) { output += "editinline "; } copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EditInline; } } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.EdFindable) != 0) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.EdFindable; output += "edfindable "; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Deprecated) != 0) { output += "deprecated "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Deprecated; } // It is important to check for global before checking config! first if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.GlobalConfig) != 0) { output += "globalconfig "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.GlobalConfig; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Config; } else if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Config) != 0) { #if XCOM2 if (ConfigName != null && !ConfigName.IsNone()) { output += "config(" + ConfigName.ToString() + ") "; } else { #endif output += "config "; #if XCOM2 } #endif copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Config; } if ((PropertyFlags & (ulong)Flags.PropertyFlagsLO.Localized) != 0) { output += "localized "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Localized; } if (Package.Version == 128) { if (HasPropertyFlag(Flags.PropertyFlagsLO.Cache)) { copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Cache; output += "cache "; } } if (HasPropertyFlag(Flags.PropertyFlagsLO.Transient)) { output += "transient "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Transient; } if (HasPropertyFlag(Flags.PropertyFlagsLO.Travel)) { output += "travel "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Travel; } if (HasPropertyFlag(Flags.PropertyFlagsLO.Input)) { output += "input "; copyFlags &= ~(ulong)Flags.PropertyFlagsLO.Input; } } // Local's may never output any of their implied flags! if (!IsParm() && Super != null && String.Compare(Super.GetClassName(), "Function", StringComparison.OrdinalIgnoreCase) == 0) { return(string.Empty); } // alright... //return "/*" + UnrealMethods.FlagToString( PropertyFlags ) + "*/ " + output; return(copyFlags != 0 ? "/*" + UnrealMethods.FlagToString(copyFlags) + "*/ " + output : output); }