Esempio n. 1
0
        public UITreeNode[] LoadChildren(
            IPythonMemoryReader MemoryReader)
        {
            var Dict = this.Dict;

            if (null != Dict)
            {
                DictEntryChildren = Dict.EntryForKeyStr("children");
            }

            if (null != DictEntryChildren)
            {
                if (DictEntryChildren.me_value.HasValue)
                {
                    ChildrenList = new PyChildrenList(DictEntryChildren.me_value.Value, MemoryReader);

                    ChildrenList.LoadDict(MemoryReader);

                    ChildrenList.LoadChildren(MemoryReader);
                }
            }

            if (null != ChildrenList)
            {
                children = ChildrenList.children;
            }

            return(children);
        }
Esempio n. 2
0
        public UITreeNode[] LoadChildren(
            IPythonMemoryReader MemoryReader)
        {
            var Dict = this.Dict;

            if (null != Dict)
            {
                DictEntryChildren = Dict.EntryForKeyStr("_childrenObjects");
            }

            if (null != DictEntryChildren)
            {
                if (DictEntryChildren.me_value.HasValue)
                {
                    ChildrenList = new PyList(DictEntryChildren.me_value.Value, MemoryReader);
                }
            }

            if (null != ChildrenList)
            {
                var Items = ChildrenList.Items;

                if (null != Items)
                {
                    children = Items.Select((ChildAddress) => new UITreeNode(ChildAddress, MemoryReader)).ToArray();
                }
            }

            return(children);
        }
Esempio n. 3
0
        public IEnumerable <UITreeNode> EnumerateChildrenTransitive(
            IPythonMemoryReader MemoryReader,
            int?DepthMax = null)
        {
            if (DepthMax <= 0)
            {
                yield break;
            }

            this.LoadDict(MemoryReader);

            this.LoadChildren(MemoryReader);

            var children = this.children;

            if (null == children)
            {
                yield break;
            }

            foreach (var child in children)
            {
                yield return(child);

                foreach (var childChild in child.EnumerateChildrenTransitive(MemoryReader, DepthMax - 1))
                {
                    yield return(childChild);
                }
            }
        }
Esempio n. 4
0
        /// <summary>
        /// returns the Root of the UITree.
        /// </summary>
        /// <param name="MemoryReader"></param>
        /// <returns></returns>
        static public UITreeNode UIRoot(
            IPythonMemoryReader MemoryReader)
        {
            var CandidateAddresses = PyTypeObject.EnumeratePossibleAddressesOfInstancesOfPythonTypeFilteredByObType(MemoryReader, "UIRoot");

            var CandidatesWithChildrenCount = new List <KeyValuePair <UITreeNode, int> >();

            foreach (var CandidateAddress in CandidateAddresses)
            {
                var Candidate = new UITreeNode(CandidateAddress, MemoryReader);

                int CandidateChildrenCount = 0;

                {
                    var CandidateChildren = Candidate.EnumerateChildrenTransitive(MemoryReader);

                    if (null != CandidateChildren)
                    {
                        CandidateChildrenCount = CandidateChildren.Count();
                    }
                }

                CandidatesWithChildrenCount.Add(new KeyValuePair <UITreeNode, int>(Candidate, CandidateChildrenCount));
            }

            //	return the candidate the most children nodes where found in.
            return
                (CandidatesWithChildrenCount
                 .OrderByDescending((CandidateWithChildrenCount) => CandidateWithChildrenCount.Value)
                 .FirstOrDefault()
                 .Key);
        }
Esempio n. 5
0
        public PyTypeObject LoadType(IPythonMemoryReader MemoryReader)
        {
            if (ob_type.HasValue)
            {
                TypeObject = MemoryReader.TypeFromAddress(ob_type.Value);
            }

            return(TypeObject);
        }
Esempio n. 6
0
        static public MemoryReadingReportModel.Root BuildReport(IPythonMemoryReader reader)
        {
            var uiRoot = Sanderling.MemoryReading.EveOnline.UIRoot(reader);

            return(new MemoryReadingReportModel.Root
            {
                UITreeRoot = BuildReport(uiRoot, reader),
            });
        }
Esempio n. 7
0
        public PyDict LoadDict(
            IPythonMemoryReader MemoryReader)
        {
            if (ref_dict.HasValue)
            {
                Dict = new PyDict(ref_dict.Value, MemoryReader, 0x1000);
            }

            return(Dict);
        }
Esempio n. 8
0
        static PyObject PyObjSpecific(PyObject pyObj, IPythonMemoryReader reader)
        {
            if (pyObj == null)
            {
                return(null);
            }

            var constructor =
                SetTypeNameAndConstructor?.FirstOrDefault(typeNameAndConstructor => typeNameAndConstructor.Key == pyObj?.TypeObject?.tp_name_Val).Value;

            return(constructor?.Invoke(pyObj.BaseAddress, reader));
        }
Esempio n. 9
0
        /// <summary>
        /// returns the root of the UI tree.
        /// </summary>
        /// <param name="MemoryReader"></param>
        /// <returns></returns>
        static public UITreeNode UITreeRoot(
            IPythonMemoryReader MemoryReader)
        {
            var candidateAddresses = PyTypeObject.EnumeratePossibleAddressesOfInstancesOfPythonTypeFilteredByObType(MemoryReader, "UIRoot");

            //	return the candidate tree with the largest number of nodes.
            return
                (candidateAddresses
                 .Select(candidateAddress => new UITreeNode(candidateAddress, MemoryReader))
                 .OrderByDescending(candidate => candidate.EnumerateChildrenTransitive(MemoryReader)?.Count())
                 .FirstOrDefault());
        }
Esempio n. 10
0
        static MemoryReadingReportModel.DictEntry BuildReport(PyDictEntry dictEntry, IPythonMemoryReader reader)
        {
            if (dictEntry == null)
            {
                return(null);
            }

            return(new MemoryReadingReportModel.DictEntry
            {
                Key = BuildReportForPyObjectFromAddress(dictEntry.me_key ?? 0, reader),
                Value = BuildReportForPyObjectFromAddress(dictEntry.me_value ?? 0, reader),
            });
        }
Esempio n. 11
0
        static public string TypeNameForObjectWithAddress(UInt32 ObjectAddress, IPythonMemoryReader MemoryReader)
        {
            var Object = new PyObject(ObjectAddress, MemoryReader);

            Object.LoadType(MemoryReader);

            var ObjectTypeObject = Object.TypeObject;

            if (null == ObjectTypeObject)
            {
                return(null);
            }

            return(ObjectTypeObject.tp_name_Val);
        }
Esempio n. 12
0
        static MemoryReadingReportModel.PythonObject BuildReport(PyObject pyObj, IPythonMemoryReader reader)
        {
            pyObj.LoadType(reader);

            var specific = PyObjSpecific(pyObj, reader);

            object valueMappedToClrObj =
                (specific as PyStr)?.String;

            return(new MemoryReadingReportModel.PythonObject
            {
                BaseAddress = pyObj.BaseAddress,
                PyTypeObjAddress = pyObj.ob_type,
                PyTypeName = pyObj?.TypeObject?.tp_name_Val,
                ValueMappedToClrObj = valueMappedToClrObj,
            });
        }
Esempio n. 13
0
        static MemoryReadingReportModel.UINode BuildReport(UITreeNode node, IPythonMemoryReader reader)
        {
            node.LoadType(reader);
            node.LoadDict(reader);
            node.LoadChildren(reader);

            var immediateChildrenReports = node.children?.Select(childNode => BuildReport(childNode, reader))?.ToArray();

            return(new MemoryReadingReportModel.UINode
            {
                BaseAddress = node.BaseAddress,
                PyTypeObjAddress = node.ob_type,
                PyTypeName = node.TypeObject?.tp_name_Val,
                Dict = BuildReport(node.Dict, reader),
                Children = immediateChildrenReports,
                ChildrenTransitiveCount =
                    (immediateChildrenReports?.Length + immediateChildrenReports?.Select(immediateChild => immediateChild?.ChildrenTransitiveCount ?? 0)?.Sum()) ?? 0,
            });
        }
Esempio n. 14
0
        static MemoryReadingReportModel.Dict BuildReport(PyDict dict, IPythonMemoryReader reader)
        {
            if (dict == null)
            {
                return(null);
            }

            dict.LoadType(reader);

            var slotsFiltered =
                dict?.Slots
                ?.Take(dictSlotCountUpperBound)
                ?.Select((slot, index) => BuildReport(slot, reader)?.WithSlotIndex(index))
                ?.Where(slotReport => slotReport?.Key != null || slotReport?.Value != null)
                ?.ToArray();

            return(new MemoryReadingReportModel.Dict
            {
                BaseAddress = dict.BaseAddress,
                PyTypeObjAddress = dict.ob_type,
                PyTypeName = dict.TypeObject?.tp_name_Val,
                SlotsFiltered = slotsFiltered,
            });
        }
Esempio n. 15
0
 static MemoryReadingReportModel.PythonObject BuildReportForPyObjectFromAddress(Int64 pyObjAddress, IPythonMemoryReader reader) =>
 pyObjAddress == 0 ? null :
 BuildReport(new PyObject(pyObjAddress, reader), reader);