public void LaadeListeOktetWenBisherKlainerAlsAnzaalVermuutung(IMemoryReader DaatenKwele)
        {
            if (null == DaatenKwele)
            {
                return;
            }

            var ListeOktetAnzaal = Math.Min(0x10000, ListeOktetAnzaalBerecne());

            var ListeOktetLeese = false;

            if (null == ListeOktet)
            {
                ListeOktetLeese = true;
            }
            else
            {
                if (ListeOktet.Length < ListeOktetAnzaal)
                {
                    ListeOktetLeese = true;
                }
            }

            if (ListeOktetLeese)
            {
                ListeOktet = DaatenKwele.ListeOktetLeeseVonAdrese(HerkunftAdrese, ListeOktetAnzaal, false);
            }
        }
        override public void LaadeReferenziirte(IMemoryReader DaatenKwele)
        {
            if (null == DaatenKwele)
            {
                return;
            }

            var Ref_ob_item = this.Ref_ob_item;

            if (0 != Ref_ob_item)
            {
                var ListeItemAnzaal = ob_size;

                var ItemListeOktetAnzaal = 4;

                var ListeItemListeOktet = DaatenKwele.ListeOktetLeeseVonAdrese(Ref_ob_item, ListeItemAnzaal * ItemListeOktetAnzaal, false);

                var ListeItemRef = new   List <Int64>();

                for (int ItemIndex = 0; ItemIndex < ListeItemListeOktet.LongLength / ItemListeOktetAnzaal; ItemIndex++)
                {
                    var InBlokItemAdrese = ItemIndex * ItemListeOktetAnzaal;

                    var ItemRef = UInt32AusListeOktet(ListeItemListeOktet, InBlokItemAdrese) ?? 0;

                    ListeItemRef.Add(ItemRef);
                }

                this.ListeItemRef = ListeItemRef.ToArray();
            }
        }
        public void LaadeReferenziirte(
            IMemoryReader DaatenKwele,
            int?ListeEntryAnzaalScrankeMax)
        {
            if (null == DaatenKwele)
            {
                return;
            }

            var AnnaameRefListeDictEntry = this.AnnaameRefListeDictEntry;
            var AnnaameDictEntryAnzaal   = this.AnnaameDictEntryAnzaal;

            if (AnnaameRefListeDictEntry.HasValue &&
                AnnaameDictEntryAnzaal.HasValue)
            {
                var ListeEntryAnzaal = AnnaameDictEntryAnzaal.Value;

                if (ListeEntryAnzaal < 0)
                {
                    return;
                }

                if (ListeEntryAnzaalScrankeMax < ListeEntryAnzaal)
                {
                    return;
                }

                var EntryListeOktetAnzaal = SictAuswertPythonDictEntry.EntryListeOktetAnzaal;

                var ListeEntryListeOktet = DaatenKwele.ListeOktetLeeseVonAdrese(AnnaameRefListeDictEntry.Value, ListeEntryAnzaal * EntryListeOktetAnzaal, false);

                if (null != ListeEntryListeOktet)
                {
                    var ListeEntry = new List <SictAuswertPythonDictEntryAinfac>();

                    ListeEntryAnzaal = (int)(ListeEntryListeOktet.LongLength / EntryListeOktetAnzaal);

                    {
                        var ListeEntryListeInt = new UInt32[ListeEntryListeOktet.Length / 4];

                        Buffer.BlockCopy(ListeEntryListeOktet, 0, ListeEntryListeInt, 0, ListeEntryListeInt.Length * 4);

                        for (int EntryIndex = 0; EntryIndex < ListeEntryAnzaal; EntryIndex++)
                        {
                            var Entry = new SictAuswertPythonDictEntryAinfac(ListeEntryListeInt, EntryIndex);

                            ListeEntry.Add(Entry);
                        }
                    }

                    this.ListeEntry = ListeEntry.ToArray();
                }
            }
        }
        override public void Aktualisiire(
            IMemoryReader ausProzesLeeser,
            out bool geändert,
            Int64 zait,
            int?zuLeeseListeOktetAnzaal = null)
        {
            var InternZuLeeseListeOktetAnzaal = ObjektBeginListeOktetAnzaal;

            if (zuLeeseListeOktetAnzaal.HasValue)
            {
                InternZuLeeseListeOktetAnzaal = Math.Max(zuLeeseListeOktetAnzaal.Value, InternZuLeeseListeOktetAnzaal);
            }

            base.Aktualisiire(
                ausProzesLeeser,
                out geändert,
                zait,
                InternZuLeeseListeOktetAnzaal);

            var ObjektBegin = this.ObjektBegin;

            var length  = ObjektBegin.BaiPlus8Int32;
            var Ref_str = ObjektBegin.BaiPlus12UInt32;

            this.length  = length;
            this.Ref_str = Ref_str;

            hash       = ObjektBegin.BaiPlus16Int32;
            Ref_defenc = ObjektBegin.BaiPlus20UInt32;

            string WertString = null;

            try
            {
                if (null == ausProzesLeeser)
                {
                    return;
                }

                var LengthBescrankt = Math.Max(0, Math.Min(LengthScranke, length));

                LengthScrankeAingehalte = LengthBescrankt == length;

                var ListeOktetAnzaal = LengthBescrankt * 2;

                var StringListeOktet = ausProzesLeeser.ListeOktetLeeseVonAdrese(Ref_str, ListeOktetAnzaal, false);

                WertString = (null == StringListeOktet) ? null : Encoding.Unicode.GetString(StringListeOktet);
            }
            finally
            {
                this.WertString = WertString;
            }
        }
        protected int     ZwiscenscpaicerListeOktetFüleAusProzes(
            IMemoryReader AusProzesLeeser,
            int ListeOktetAnzaal)
        {
            var HerkunftAdrese = this.HerkunftAdrese;

            var ListeOktetAnzaalBescrankt = Math.Max(0, ListeOktetAnzaal);

            var VorherZwiscenscpaicerListeOktet = AusScpaicerLeeseLezteListeOktetUndAnzaal.Key;

            var ZwiscenscpaicerListeOktet = VorherZwiscenscpaicerListeOktet;

            if (null != ZwiscenscpaicerListeOktet)
            {
                if (ZwiscenscpaicerListeOktet.Length < ListeOktetAnzaalBescrankt ||
                    ListeOktetAnzaalBescrankt < ZwiscenscpaicerListeOktet.Length / 2 - 10)
                {
                    //	Vorhandener Puffer ist zu klain oder zu groos und wird daher nit waiterverwendet.
                    ZwiscenscpaicerListeOktet = null;
                }
            }

            if (null == ZwiscenscpaicerListeOktet)
            {
                ZwiscenscpaicerListeOktet = new byte[ListeOktetAnzaalBescrankt + 4];
            }
            else
            {
                //	Für Debugging: für den Fal das leese feelscläägt wääre es üübersictlicer wen Array nuur 0 enthalt.
                Array.Clear(ZwiscenscpaicerListeOktet, 0, ListeOktetAnzaalBescrankt);
            }

            int GeleeseListeOktetAnzaal = 0;

            try
            {
                if (null == AusProzesLeeser)
                {
                    return(GeleeseListeOktetAnzaal);
                }

                GeleeseListeOktetAnzaal = (int)AusProzesLeeser.ListeOktetLeeseVonAdrese(HerkunftAdrese, ListeOktetAnzaalBescrankt, ZwiscenscpaicerListeOktet);
            }
            finally
            {
                this.AusScpaicerLeeseLezteListeOktetUndAnzaal = new KeyValuePair <byte[], int>(ZwiscenscpaicerListeOktet, GeleeseListeOktetAnzaal);
            }

            return(GeleeseListeOktetAnzaal);
        }
        override public void LaadeReferenziirte(IMemoryReader DaatenKwele)
        {
            if (null == DaatenKwele)
            {
                return;
            }

            var Ref_str = this.Ref_str;
            var length  = this.length;

            if (0 != Ref_str)
            {
                /*
                 * 2013.10.15
                 * Beobactung von Testsystem System.OverflowException mit Callstack:
                 *
                 * bei System.IntPtr.ToInt32()
                 * bei Optimat.Glob.Kernel32ReadProcessMemory(IntPtr ProcessHandle, Int64 Adrese, Int64 ListeOktetAnzaalScrankeMax) in t:\Günta\Projekt\Ausboit VS\Debug W³\Entwiklung.Behältnis[1]\Anwendung\Optimat.PIpMR.Grepo\sln\Optimat.PIpMR.Grepo\Glob\Optimat.Glob.cs:Zeile 1608.
                 * bei Optimat.SictAusProzesDirektLeeser.InternListeOktetLeeseVonAdrese(Int64 Adrese, Int64 ListeOktetZuLeeseAnzaal) in t:\Günta\Projekt\Ausboit VS\Debug W³\Entwiklung.Behältnis[1]\Anwendung\Optimat.PIpMR.Grepo\sln\Optimat.PIpMR.Grepo\ProzesScnapscus.cs:Zeile 20.
                 * bei Optimat.EveOnline.SictAusProzesZuusctandLeeser.ListeOktetLeeseVonAdrese(Int64 Adrese, Int64 ListeOktetZuLeeseAnzaal, Boolean GibZurükNullWennGeleeseneAnzahlKlainer) in t:\Günta\Projekt\Ausboit VS\Debug W³\Entwiklung.Behältnis[1]\Anwendung\Optimat.PIpMR.Grepo\sln\Optimat.PIpMR.Grepo\ScpezEveOnln\Nuzer\ProzesScpaicerInterpret.cs:Zeile 18.
                 * bei Optimat.EveOnline.SictAuswertPythonObjUnicode.LaadeReferenziirte(SictAusProzesZuusctandLeeser DaatenKwele) in t:\Günta\Projekt\Ausboit VS\Debug W³\Entwiklung.Behältnis[1]\Anwendung\Optimat.PIpMR.Grepo\sln\Optimat.PIpMR.Grepo\ScpezEveOnln\Nuzer\ProzesScpaicerInterpret.cs:Zeile 1041.
                 * bei Optimat.EveOnline.SictProzesAuswertZuusctand.LaadeReferenziirte(SictAuswertPyObjGbsAst PyObj, SictAusProzesZuusctandLeeser ProzesLeeser, Boolean ObjSezeNaacScpaicer, Boolean ErmitleTypNurAusScpaicer, Nullable`1 DictListeEntryAnzaalScrankeMax) in t:\Günta\Projekt\Ausboit VS\Debug W³\Entwiklung.Behältnis[1]\Anwendung\Optimat.PIpMR.Grepo\sln\Optimat.PIpMR.Grepo\ScpezEveOnln\Nuzer\ProzesAuswertZuusctand.cs:Zeile 2121.
                 * bei Optimat.EveOnline.Nuzer.SictProzesAuswert.Berecne(SictAusProzesZuusctandLeeser ProzesLeeser) in t:\Günta\Projekt\Ausboit VS\Debug W³\Entwiklung.Behältnis[1]\Anwendung\Optimat.PIpMR.Grepo\sln\Optimat.PIpMR.Grepo\ScpezEveOnln\Nuzer\ProzesAuswert.cs:Zeile 623.
                 * bei Optimat.EveOnline.Nuzer.SictProzesAuswert.Berecne() in t:\Günta\Projekt\Ausboit VS\Debug W³\Entwiklung.Behältnis[1]\Anwendung\Optimat.PIpMR.Grepo\sln\Optimat.PIpMR.Grepo\ScpezEveOnln\Nuzer\ProzesAuswert.cs:Zeile 568.
                 * .......
                 *
                 * Daher Ainfüürung LengthBescrankt.
                 *
                 * var ListeOktetAnzaal = length * 2;
                 * */

                var LengthBescrankt = Math.Max(0, Math.Min(LengthScranke, length));

                LengthScrankeAingehalte = LengthBescrankt == length;

                var ListeOktetAnzaal = LengthBescrankt * 2;

                var StringListeOktet = DaatenKwele.ListeOktetLeeseVonAdrese(Ref_str, ListeOktetAnzaal, false);

                String = Encoding.Unicode.GetString(StringListeOktet);
            }
        }
Exemple #7
0
        public static byte[] ListeOktetLeeseVonAdrese(this IMemoryReader reader, long adrese, long listeOktetZuLeeseAnzaal, bool gibZurükNullWennGeleeseneAnzahlKlainer = false)
        {
            byte[] array = new byte[listeOktetZuLeeseAnzaal];
            long   num   = reader?.ListeOktetLeeseVonAdrese(adrese, listeOktetZuLeeseAnzaal, array) ?? 0;

            if (num < listeOktetZuLeeseAnzaal)
            {
                if (gibZurükNullWennGeleeseneAnzahlKlainer)
                {
                    return(null);
                }
                int num2 = (int)num;
                if (num2 != num)
                {
                    throw new NotImplementedException("GeleeseListeOktetAnzaalInt32 != GeleeseListeOktetAnzaal");
                }
                byte[] array2 = new byte[num2];
                Buffer.BlockCopy(array, 0, array2, 0, num2);
                return(array2);
            }
            return(array);
        }
        override public void LaadeReferenziirte(IMemoryReader DaatenKwele)
        {
            base.LaadeReferenziirte(DaatenKwele);

            if (null == DaatenKwele)
            {
                return;
            }

            var ReferenzTp_name = this.ReferenzTp_name;

            if (0 != ReferenzTp_name)
            {
                var TpNameListeOktet = DaatenKwele.ListeOktetLeeseVonAdrese(ReferenzTp_name, 0x100, false);

                if (null != TpNameListeOktet)
                {
                    var TpName = Encoding.ASCII.GetString(TpNameListeOktet.TakeWhile((t) => 0 != t).ToArray());

                    this.tp_name = TpName;
                }
            }
        }
        public void LaadeReferenziirte(
            IMemoryReader DaatenKwele,
            int?ListeEntryAnzaalScrankeMax)
        {
            if (null == DaatenKwele)
            {
                return;
            }

            var Ref_ma_table = this.Ref_ma_table;

            var ma_mask = this.ma_mask;
            var ma_used = this.ma_used;
            var ma_fill = this.ma_fill;

            if (ma_mask < ma_fill)
            {
                return;
            }

            if (0 != Ref_ma_table)
            {
                var ListeEntryAnzaal = ma_mask + 1;

                if (ListeEntryAnzaal < 0)
                {
                    return;
                }

                if (ListeEntryAnzaalScrankeMax < ListeEntryAnzaal)
                {
                    return;
                }

                var EntryListeOktetAnzaal = SictAuswertPythonDictEntry.EntryListeOktetAnzaal;

                var ListeEntryListeOktet = DaatenKwele.ListeOktetLeeseVonAdrese(Ref_ma_table, ListeEntryAnzaal * EntryListeOktetAnzaal, false);

                if (null != ListeEntryListeOktet)
                {
                    /*
                     * 2013.07.18
                     * Perf: Umsctelung auf SictAuswertPythonDictEntryAinfac
                     *
                     * var ListeEntry = new List<SictAuswertPythonDictEntry>();
                     * */

                    var ListeEntry = new List <SictAuswertPythonDictEntryAinfac>();

                    ListeEntryAnzaal = (int)(ListeEntryListeOktet.LongLength / EntryListeOktetAnzaal);

                    {
                        var ListeEntryListeInt = new UInt32[ListeEntryListeOktet.Length / 4];

                        Buffer.BlockCopy(ListeEntryListeOktet, 0, ListeEntryListeInt, 0, ListeEntryListeInt.Length * 4);

                        for (int EntryIndex = 0; EntryIndex < ListeEntryAnzaal; EntryIndex++)
                        {
                            var Entry = new SictAuswertPythonDictEntryAinfac(ListeEntryListeInt, EntryIndex);

                            ListeEntry.Add(Entry);
                        }
                    }

                    this.ListeDictEntry = ListeEntry.ToArray();
                }
            }
        }
        override public void Aktualisiire(
            IMemoryReader AusProzesLeeser,
            out bool Geändert,
            Int64 Zait,
            int?ZuLeeseListeOktetAnzaal = null)
        {
            ObjektListeOktetAnzaal = ObjektBeginListeOktetAnzaal;

            base.Aktualisiire(
                AusProzesLeeser,
                out Geändert,
                Zait,
                ZuLeeseListeOktetAnzaal);

            var ObjektBegin = this.ObjektBegin;

            var AnnaameDictEntryAnzaal   = ObjektBegin.BaiPlus16Int32;
            var AnnaameRefListeDictEntry = ObjektBegin.BaiPlus20UInt32;

            this.AnnaameDictEntryAnzaal   = AnnaameDictEntryAnzaal;
            this.AnnaameRefListeDictEntry = AnnaameRefListeDictEntry;

            SictPyDictEntry32[] ListeDictEntry = null;

            try
            {
                if (null == AusProzesLeeser)
                {
                    return;
                }

                if (AnnaameDictEntryAnzaal < 0)
                {
                    return;
                }

                if (0 < AnnaameDictEntryAnzaal)
                {
                }

                if (ListeEntryAnzaalScrankeMax < AnnaameDictEntryAnzaal)
                {
                    return;
                }

                var EntryListeOktetAnzaal = SictPyDictEntry32.EntryListeOktetAnzaal;

                var ListeEntryListeOktet = AusProzesLeeser.ListeOktetLeeseVonAdrese(AnnaameRefListeDictEntry, AnnaameDictEntryAnzaal * EntryListeOktetAnzaal, false);

                if (null != ListeEntryListeOktet)
                {
                    var ListeEntryListeOktetUnverändert = false;

                    {
                        //	Berecne ob Scpaicerinhalt bai Adrese Ref_ma_table sait lezter Aktualisatioon unverändert isc.
                    }

                    if (!ListeEntryListeOktetUnverändert)
                    {
                        //	Scpaicerinhalt wurde verändert, noies Array mit Entry anleege. (andere Funktioone di diises nuze werde di Identitäät des Array verwende um zu ermitle ob änderung Sctatgefunde hat.

                        var GeleeseListeEntryAnzaal = (int)(ListeEntryListeOktet.Length / EntryListeOktetAnzaal);

                        var InternListeDictEntry = new SictPyDictEntry32[GeleeseListeEntryAnzaal];

                        var structHandle = GCHandle.Alloc(InternListeDictEntry, GCHandleType.Pinned);

                        try
                        {
                            Marshal.Copy(ListeEntryListeOktet, 0, structHandle.AddrOfPinnedObject(), InternListeDictEntry.Length * EntryListeOktetAnzaal);
                        }
                        finally
                        {
                            structHandle.Free();
                        }

                        ListeDictEntry = InternListeDictEntry;
                    }
                }
            }
            finally
            {
                this.ListeDictEntry = ListeDictEntry;
            }
        }
Exemple #11
0
        override public void Aktualisiire(
            IMemoryReader ausProzesLeeser,
            out bool geändert,
            Int64 zait,
            int?zuLeeseListeOktetAnzaal = null)
        {
            UInt32[] ListeItemRef = null;

            try
            {
                base.Aktualisiire(
                    ausProzesLeeser,
                    out geändert,
                    zait,
                    zuLeeseListeOktetAnzaal);

                var Ref_ob_item = ObjektBegin.BaiPlus12UInt32;

                this.Ref_ob_item = Ref_ob_item;
                allocated        = ObjektBegin.BaiPlus16Int32;

                if (null == ausProzesLeeser)
                {
                    return;
                }

                if (0 != Ref_ob_item && 0 <= ob_size)
                {
                    var ListeItemAnzaal = ob_size;

                    var ListeItemAnzaalScrankeMax = this.ListeItemAnzaalScrankeMax;

                    if (ListeItemAnzaalScrankeMax.HasValue)
                    {
                        ListeItemAnzaal = Math.Min(ListeItemAnzaal, ListeItemAnzaalScrankeMax.Value);
                    }

                    if (0x1000 < ListeItemAnzaal)
                    {
                        return;
                    }

                    var ItemListeOktetAnzaal = 4;

                    var ListeItemListeOktet = ausProzesLeeser.ListeOktetLeeseVonAdrese(Ref_ob_item, ListeItemAnzaal * ItemListeOktetAnzaal, false);

                    if (null != ListeItemListeOktet)
                    {
                        var GeleeseListeItemAnzaal = ListeItemListeOktet.Length / ItemListeOktetAnzaal;

                        var InternListeItemRef = new UInt32[GeleeseListeItemAnzaal];

                        Buffer.BlockCopy(ListeItemListeOktet, 0, InternListeItemRef, 0, GeleeseListeItemAnzaal * ItemListeOktetAnzaal);

                        ListeItemRef = InternListeItemRef;
                    }
                }
            }
            finally
            {
                this.ListeItemRef = ListeItemRef;
            }
        }