public void OnNext(string value)
        {
            var parsedLine = DolphinMbpWriteLine.ParseString(value);

            if (parsedLine?.WriteSize == 32)
            {
                uint chunkOffset = (parsedLine.MemoryAddr - BITS_BASE_ADDRESS) / 4;

                // If the memory address is less than the flags base address, flagNum will overflow
                // so we only need to check flagNum < FLAGS_SIZE
                if (chunkOffset >= BITS_CHUNKS_COUNT)
                {
                    return;
                }

                uint oldChunk = cachedBitChunks[chunkOffset];
                uint newChunk = parsedLine.Value;
                cachedBitChunks[chunkOffset] = newChunk;

                List <int> changedBits = BitUtils.GetListOfBits((int)(oldChunk ^ newChunk));

                var eventArgs = new SoALBitChangedEventArgs
                {
                    ChunkNumber = (int)chunkOffset
                };

                foreach (int b in changedBits)
                {
                    eventArgs.ChunkBit   = b;
                    eventArgs.IsBeingSet = (newChunk & (1 << b)) != 0;

                    OnChange?.Invoke(this, eventArgs);
                }
            }
        }
Example #2
0
        public void OnNext(string value)
        {
            var parsedLine = DolphinMbpWriteLine.ParseString(value);

            if (parsedLine?.WriteSize == 8)
            {
                uint flagNum = parsedLine.MemoryAddr - FLAGS_BASE_ADDRESS;

                // If the memory address is less than the flags base address, flagNum will overflow
                // so we only need to check flagNum < FLAGS_SIZE
                if (flagNum >= FLAGS_SIZE)
                {
                    return;
                }

                byte oldFlag = cachedFlags[flagNum];
                cachedFlags[flagNum] = (byte)parsedLine.Value;

                if (oldFlag != parsedLine.Value)
                {
                    var eventArgs = new SoALFlagChangedEventArgs {
                        FlagNumber = (int)flagNum,
                        OldValue   = oldFlag,
                        NewValue   = parsedLine.Value
                    };
                    OnChange?.Invoke(this, eventArgs);
                }
            }
        }
        public static DolphinMbpWriteLine ParseString(string line)
        {
            Match m = parseRegex.Match(line);

            DolphinMbpWriteLine result = null;

            if (m.Success)
            {
                var funcaddr  = uint.Parse(m.Groups["funcaddr"].Value, System.Globalization.NumberStyles.HexNumber);
                var funcname  = m.Groups["funcname"].Value;
                var writesize = int.Parse(m.Groups["writesize"].Value);
                var value     = uint.Parse(m.Groups["value"].Value, System.Globalization.NumberStyles.HexNumber);
                var memaddr   = uint.Parse(m.Groups["flagaddr"].Value, System.Globalization.NumberStyles.HexNumber);

                result = new DolphinMbpWriteLine(funcaddr, funcname, writesize, value, memaddr);
            }

            return(result);
        }