コード例 #1
0
        public static void DeserializeGivenChangeMask(
            BinaryReader reader, NetworkedComponentTypeInfo networkedComponentTypeInfo,
            object oldValue, uint changeMask
            )
        {
            byte changeMaskBitIndex = 0;

            foreach (var field in networkedComponentTypeInfo.ThingsToSynchronize)
            {
                if (BitUtilities.GetBit(changeMask, changeMaskBitIndex))
                {
                    if (field.FieldInfo != null)
                    {
                        var newFieldValue = Deserialize(
                            reader, field.FieldInfo.FieldType,
                            field.IsNullableIfReferenceType, field.AreElementsNullableIfReferenceType
                            );
                        field.FieldInfo.SetValue(oldValue, newFieldValue);
                    }
                    else if (field.PropertyInfo != null)
                    {
                        var newFieldValue = Deserialize(
                            reader, field.PropertyInfo.PropertyType,
                            field.IsNullableIfReferenceType, field.AreElementsNullableIfReferenceType
                            );
                        field.PropertyInfo.SetValue(oldValue, newFieldValue);
                    }
                }
                changeMaskBitIndex++;
            }
        }
コード例 #2
0
    public void TestUint128(string aStr, string bStr, byte expected)
    {
        UInt128 a = new UInt128(BigInteger.Parse(aStr));
        UInt128 b = new UInt128(BigInteger.Parse(bStr));

        BitUtilities.FindCommonPrefixSize(a, b).Should().Be(expected);
    }
コード例 #3
0
        private void LogReceivedStateDelta(NetworkedGameState networkedGameState)
        {
            OsFps.Logger.Log(networkedGameState.SequenceNumber);

            for (var i = 0; i < networkedGameState.NetworkedComponentTypeInfos.Count; i++)
            {
                var networkedComponentTypeInfo = networkedGameState.NetworkedComponentTypeInfos[i];
                var networkedComponentInfos    = networkedGameState.NetworkedComponentInfoLists[i];

                foreach (var componentInfo in networkedComponentInfos)
                {
                    var synchronizedFieldNames = BitUtilities.GetSetBitIndices(componentInfo.ChangeMask)
                                                 .Select(bitIndex =>
                    {
                        if (bitIndex >= networkedComponentTypeInfo.ThingsToSynchronize.Count)
                        {
                            return(null);
                        }

                        var thingToSynchronize = networkedComponentTypeInfo.ThingsToSynchronize[bitIndex];
                        var thingName          = (thingToSynchronize.FieldInfo != null)
                                ? thingToSynchronize.FieldInfo.Name
                                : thingToSynchronize.PropertyInfo.Name;
                        return(thingName);
                    })
                                                 .Where(x => x != null)
                                                 .ToArray();

                    OsFps.Logger.Log(networkedComponentTypeInfo.StateType.Name + ": " + Convert.ToString(componentInfo.ChangeMask, 2) + " | " + string.Join(", ", synchronizedFieldNames));
                }
            }
        }
コード例 #4
0
        /// <summary>
        /// Get the opcode.
        /// </summary>
        /// <param name="inputBits">instruction bits</param>
        /// <returns>Operation</returns>
        public Operation DecodeOpcode(int inputBits)
        {
            // Get mask for opcode + InstructionID
            opcode = inputBits & BitUtilities.CreateBitMask(opcodeStartBit, 15);

            switch (opcode)
            {
            case (int)opcodeIdentificationHexLiterals.hexADD:
                return(new ADDoperation());

            case (int)opcodeIdentificationHexLiterals.hexADC:
                return(new ADCoperation());

            case (int)opcodeIdentificationHexLiterals.hexSUB:
                return(new SUBoperation());

            case (int)opcodeIdentificationHexLiterals.hexMUL:
                return(new MULoperation());

            case (int)opcodeIdentificationHexLiterals.hexDIV:
                return(new DIVoperation());

            case (int)opcodeIdentificationHexLiterals.hexMOD:
                return(new MODoperation());

            case (int)opcodeIdentificationHexLiterals.hexAND:
                return(new ANDoperation());

            case (int)opcodeIdentificationHexLiterals.hexOR:
                return(new ORoperation());

            case (int)opcodeIdentificationHexLiterals.hexNOT:
                return(new NOToperation());

            case (int)opcodeIdentificationHexLiterals.hexNAND:
                return(new NANDoperation());

            case (int)opcodeIdentificationHexLiterals.hexJMP:
                return(new JMPoperation());

            case (int)opcodeIdentificationHexLiterals.hexJC:
                return(new JCoperation());

            case (int)opcodeIdentificationHexLiterals.hexCMP:
                return(new CMPoperation());

            case (int)opcodeIdentificationHexLiterals.hexNOP:
                return(new NOPoperation());

            case (int)opcodeIdentificationHexLiterals.hexLOAD:
                return(new LOADoperation());

            case (int)opcodeIdentificationHexLiterals.hexSTOR:
                return(new STORoperation());

            default:
                throw new System.Exception("Invalid Opcode.");
            }
        }
コード例 #5
0
#pragma warning disable CS0618
    public IpAddressV4(IPAddress address) : this(BitUtilities.Reverse((uint)address.Address))
#pragma warning restore CS0618
    {
        if (address.AddressFamily != AddressFamily.InterNetwork)
        {
            throw new ArgumentException();
        }
    }
コード例 #6
0
 private IpAddressV6(byte[] address)
     : this(BitUtilities.Reverse(BitConverter.ToUInt64(address, 0)), BitUtilities.Reverse(BitConverter.ToUInt64(address, 8)))
 {
     if (address.Length != 16)
     {
         throw new ArgumentException();
     }
 }
コード例 #7
0
 /// <summary>
 /// Decode the second operand of this instruction by maskign it and
 /// 1)deteriming its value
 /// 2)assigning it a textual meaning.
 /// </summary>
 /// <param name="inputBits"></param>
 private void DecodeSecondOperand(int inputBits)
 {
     operandTwoValue = BitUtilities.MaskInput(inputBits, operandTwoStartBit, operandTwoEndBit);
     if (operandTwoValue < 0 || operandTwoValue > 15)       //used to check if valid register
     {
         operandTwoMeaning = $"OP2: Ya messed* up";
     }
     operandTwoMeaning = $"r{operandTwoValue}";
 }
コード例 #8
0
ファイル: SN76489.cs プロジェクト: hiroshica/Essgee
        public virtual void WritePort(byte port, byte data)
        {
            if (BitUtilities.IsBitSet(data, 7))
            {
                /* LATCH/DATA byte; get channel (0-3) and type (0 is tone/noise, 1 is volume) */
                latchedChannel = (byte)((data >> 5) & 0x03);
                latchedType    = (byte)((data >> 4) & 0x01);

                /* Mask off non-data bits */
                data &= 0x0F;

                /* If target is channel 3 noise (3 bits), mask off highest bit */
                if (latchedChannel == 3 && latchedType == 0)
                {
                    data &= 0x07;
                }

                /* Write to register */
                if (latchedType == 0)
                {
                    /* Data is tone/noise */
                    toneRegisters[latchedChannel] = (ushort)((toneRegisters[latchedChannel] & 0x03F0) | data);
                }
                else
                {
                    /* Data is volume */
                    volumeRegisters[latchedChannel] = data;
                }
            }
            else
            {
                /* DATA byte; mask off non-data bits */
                data &= 0x3F;

                /* Write to register */
                if (latchedType == 0)
                {
                    /* Data is tone/noise */
                    if (latchedChannel == 3)
                    {
                        /* Target is channel 3 noise, mask off excess bits and write to low bits of register */
                        toneRegisters[latchedChannel] = (ushort)(data & 0x07);
                    }
                    else
                    {
                        /* Target is not channel 3 noise, write to high bits of register */
                        toneRegisters[latchedChannel] = (ushort)((toneRegisters[latchedChannel] & 0x000F) | (data << 4));
                    }
                }
                else
                {
                    /* Data is volume; mask off excess bits and write to low bits of register */
                    volumeRegisters[latchedChannel] = (ushort)(data & 0x0F);
                }
            }
        }
コード例 #9
0
    public void CurrentUlong()
    {
        ulong expected = 0x8765432155648934;
        ulong val      = 0x3489645521436587;
        ulong res      = BitUtilities.Reverse(val);

        if (res != expected)
        {
            throw new ArgumentException();
        }
    }
コード例 #10
0
    public void CurrentUint()
    {
        uint expected = 0x21436587;
        uint val      = 0x87654321;
        uint res      = BitUtilities.Reverse(val);

        if (res != expected)
        {
            throw new ArgumentException();
        }
    }
コード例 #11
0
 /// <summary>
 /// Decode value of the immediateSwitch
 /// </summary>
 /// <param name="inputBits">our instruction</param>
 private void DecodeImmediateSwitch(int inputBits)
 {
     immediateSwitchValue = BitUtilities.MaskInput(inputBits, immediateSwitchStartBit, immediateSwitchEndBit);
     if (immediateSwitchValue == (int)ImmediateSwitchEnum.register)
     {
         immediateSwitchMeaning = "Register";
     }
     else
     {
         immediateSwitchMeaning = "Immediate";
     }
 }
コード例 #12
0
 private void DecodeFirstOperand(int inputBits)
 {
     operandOneValue = inputBits & BitUtilities.CreateBitMask(operandOneStartBit, operandOneEndBit);
     if (operandOneValue < 0 || operandOneValue > 15)
     {
         operandTwoMeaning = $"OP1: Ya fucke* up";
     }
     else
     {
         operandOneMeaning = $"r{operandOneValue}";
     }
 }
コード例 #13
0
 /// <summary>
 /// Decode the first operand of this instruction by masking it and
 /// 1) Determining its value
 /// 2) Assigning it a textual meaning. (FIX THIS)
 /// </summary>
 /// <param name="inputBits">instruction bits</param>
 private void DecodeFirstOperand(int inputBits)
 {
     operandOneValue = BitUtilities.MaskInput(inputBits, operandOneStartBit, operandOneEndBit);
     if (operandOneValue < 0 || operandOneValue > 15)
     { //used to check if valid register
         operandOneMeaning = $"OP1: Ya messed up";
     }
     else
     {
         operandOneMeaning = $"r{operandOneValue}";
     }
 }
コード例 #14
0
 /// <summary>
 /// Decode the first operand of this instruction by masking it and
 /// 1) Determining its value
 /// 2) Assigning it a textual meaning. (FIX THIS)
 /// </summary>
 /// <param name="inputBits">instruction bits</param>
 private void DecodeFirstOperand(int inputBits)
 {
     operandOneValue = BitUtilities.MaskInput(inputBits, operandOneStartBit, operandOneEndBit);
     if (operandOneValue < 0 || operandOneValue > 15)
     {
         operandTwoMeaning = $"OP1: Ya messed* up";
     }
     else
     {
         operandOneMeaning = $"r{operandOneValue}";
     }
 }
コード例 #15
0
 /// <summary>
 /// Decodes the valuie at the negative bit.
 /// </summary>
 /// <param name="inputBits">bits to be used.</param>
 private void DecodeNegativeBit(int inputBits)
 {
     negativeBitValue = BitUtilities.MaskInput(inputBits, negativeBit, negativeBit); // Get value from negative bit.
     if (negativeBitValue == 0)
     {
         negativeBitMeaning = "+";
     }
     else
     {
         negativeBitMeaning = "-";
     }
 }
コード例 #16
0
 /// <summary>
 /// Decode value of the immediateSwitch
 /// </summary>
 /// <param name="inputBits">our instruction</param>
 private void DecodeImmediateSwitch(int inputBits)
 {
     immediateSwitchValue = BitUtilities.MaskInput(inputBits, immediateSwitchStartBit, immediateSwitchEndBit);
     if (immediateSwitchValue == 0) // if using register, this is an indirect index reference
     {
         addressingModeMeaning = "an Indexed Indirect Register";
     }
     else
     {
         addressingModeMeaning = "a direct address.";
     }
 }
コード例 #17
0
        private uint ConstructMask(int denominator)
        {
            MaskBits = BitUtilities.GetNumberBitsToRepresent(denominator);
            uint retMask = 0;

            for (int i = 0; i < MaskBits; i++)
            {
                retMask  |= 1;
                retMask <<= 1;
            }
            return(retMask >> 1);
        }
コード例 #18
0
        private void DecodeBlock(BitReader readerIn)
        {
            int numCodedSymbols = readerIn.ReadInt(23);
            //Change to use stack only if the output stream is non-seekable
            //If it is seekable, then simply write the number of bytes that will be put into the stream
            //Then seek backward, writing them one by one
            Stack <int>    symbolsStack   = new Stack <int>();
            AnsCodingTable decodeTable    = AnsCodingTable.ReadTable(readerIn, EncryptionKey);
            int            bitCapacity    = BitUtilities.GetNumberBitsToRepresent(decodeTable.Denominator);
            AnsState       internalsState = new AnsState(bitCapacity, null, 0);

            internalsState.Underlying = readerIn.ReadUint(bitCapacity);
            KeyValuePair <int, int> symbolRow;

            for (int i = 0; i < numCodedSymbols; i++)
            {
                symbolRow = decodeTable.DecodePoint(internalsState.ToInt());
                symbolsStack.Push(symbolRow.Key);
                internalsState.Underlying = (uint)symbolRow.Value;
                int bitsToRead = bitCapacity - internalsState.Contained;
                for (int j = 0; j < bitsToRead; j++)
                {
                    internalsState.PushLower(readerIn.ReadBit());
                }
            }

            //Decoding finished...
            BitWriter symbolWriter = new BitWriter(Output);
            byte      numBitsToWrite;

            if (decodeTable.SymbolType == typeof(byte))
            {
                numBitsToWrite = 8;
            }
            else if (decodeTable.SymbolType == typeof(short))
            {
                numBitsToWrite = 16;
            }
            else
            {
                numBitsToWrite = 32;
            }
            while (symbolsStack.Count != 0)
            {
                int symbol = symbolsStack.Pop();
                symbolWriter.WriteLong(symbol, numBitsToWrite);
            }
        }
コード例 #19
0
    public IpAddressNetworkV6(IPAddress address, byte mask)
    {
        if (address.AddressFamily != AddressFamily.InterNetworkV6)
        {
            throw new ArgumentException();
        }

        byte[] bytes = address.GetAddressBytes();
        ulong  high  = BitUtilities.Reverse(BitConverter.ToUInt64(bytes, 0));
        ulong  low   = BitUtilities.Reverse(BitConverter.ToUInt64(bytes, 8));

        _networkAddress = new IpAddressV6(high, low);
        _mask           = mask;

        TruncateNetworkAddress(ref _networkAddress);
    }
コード例 #20
0
 /// <summary>
 /// Decode the first operand of this instruction by masking it and
 /// 1) Determining its value
 /// 2) Assigning it a textual meaning. (FIX THIS)
 /// </summary>
 /// <param name="inputBits">instruction bits</param>
 private void DecodeFirstOperand(int inputBits)
 {
     if (immediateSwitchValue == (int)ImmediateSwitchEnum.immediate)   // This is an immediate value.
     {
         operandOneValue   = BitUtilities.MaskInput(inputBits, immediateOperandStartBit, operandOneEndBit);
         operandOneMeaning = $"{operandOneValue}";
     }
     else                                                                                           // this is a register value
     {
         operandOneValue = BitUtilities.MaskInput(inputBits, operandOneStartBit, operandOneEndBit); // mask it
         if (operandOneValue < 0 || operandOneValue > 15)                                           // is it one of our general registers?
         {
             throw new System.Exception("Bad Operand One!");                                        // if not, BAD
         }
         operandOneMeaning = $"r{operandOneValue}";
     }
 }
コード例 #21
0
        private void DecodeSecondOperand(int inputBits)
        {
            operandTwoValue = inputBits & BitUtilities.CreateBitMask(operandTwoStartBit, operandTwoEndBit);

            // Immediate or Register?
            if (immediateSwitchValue == 0)   // if register
            {
                if (operandTwoValue < 0 || operandTwoValue > 15)
                {
                    operandTwoMeaning = $"OP2: Ya fucke* up";
                }
                operandTwoMeaning = $"r{operandTwoValue}";
            }
            else      // else is an immediate
            {
                operandTwoMeaning = $"#{operandTwoValue}";
            }
        }
コード例 #22
0
 /// <summary>
 /// decode the second operand and get its value and meaning
 /// </summary>
 /// <param name="inputBits">instruction bits</param>
 private void DecodeSecondOperand(int inputBits)
 {
     // Immediate or Register?
     if (immediateSwitchValue == (int)ImmediateSwitchEnum.immediate)  // This is an immediate value.
     {
         operandTwoValue   = BitUtilities.MaskInput(inputBits, immediateOperandStartBit, operandTwoEndBit);
         operandTwoMeaning = $"#{operandTwoValue}";
     }
     else
     {
         operandTwoValue = BitUtilities.MaskInput(inputBits, operandTwoStartBit, operandTwoEndBit);
         if (operandTwoValue < 0 || operandTwoValue > 15)
         {
             operandTwoMeaning = $"OP2: Ya messed up";
         }
         operandTwoMeaning = $"r{operandTwoValue}";
     }
 }
コード例 #23
0
        /// <summary>
        /// used to decode the second operand and get its meaning and value
        /// </summary>
        /// <param name="inputBits">instruction bits</param>
        private void DecodeSecondOperand(int inputBits)
        {
            operandTwoValue = BitUtilities.MaskInput(inputBits, operandTwoStartBit, operandTwoEndBit);

            // Immediate or Register?
            if (immediateSwitchValue == 0)   // if register
            {
                if (operandTwoValue < 0 || operandTwoValue > 15)
                { //used to check if valid register
                    operandTwoMeaning = $"OP2: Ya messed up";
                }
                operandTwoMeaning = $"r{operandTwoValue}";
            }
            else      // else is an immediate
            {
                operandTwoMeaning = $"#{operandTwoValue}";
            }
        }
コード例 #24
0
        /// <summary>
        /// Decodes the conditional that we look for with this statement.
        /// </summary>
        /// <param name="inputBits">instruction bits</param>
        private void DecodeConditionalValue(int inputBits)
        {
            conditionalValue = BitUtilities.MaskInput(inputBits, conditionalStartBit, conditionalEndBit);

            switch (conditionalValue)
            {
            case 0: conditionalMeaning = "Equal to"; break;

            case 1: conditionalMeaning = "Not Equal to"; break;

            case 2: conditionalMeaning = "greater than"; break;

            case 3: conditionalMeaning = "less than"; break;

            case 4: conditionalMeaning = "above or equal to"; break;

            case 5: conditionalMeaning = "Below or equal to"; break;

            default: throw new System.Exception("Invalid Conditional!");
            }
        }
コード例 #25
0
        public static uint GetChangeMask(
            NetworkedComponentTypeInfo networkedComponentTypeInfo, object newValue, object oldValue
            )
        {
            Assert.IsTrue(networkedComponentTypeInfo.ThingsToSynchronize.Count <= (8 * sizeof(uint)));

            if (oldValue == null)
            {
                return(uint.MaxValue);
            }

            uint changeMask         = 0;
            uint changeMaskBitIndex = 0;

            foreach (var field in networkedComponentTypeInfo.ThingsToSynchronize)
            {
                object oldFieldValue, newFieldValue;

                if (field.FieldInfo != null)
                {
                    oldFieldValue = field.FieldInfo.GetValue(oldValue);
                    newFieldValue = field.FieldInfo.GetValue(newValue);
                }
                else if (field.PropertyInfo != null)
                {
                    oldFieldValue = field.PropertyInfo.GetValue(oldValue);
                    newFieldValue = field.PropertyInfo.GetValue(newValue);
                }
                else
                {
                    throw new Exception("Invalid field to synchronize.");
                }

                BitUtilities.SetBit(ref changeMask, (byte)changeMaskBitIndex, !object.Equals(newFieldValue, oldFieldValue));
                changeMaskBitIndex++;
            }

            return(changeMask);
        }
コード例 #26
0
    public static IpAddressNetworkV6 MakeSupernet(IEnumerable <IpAddressNetworkV6> others)
    {
        bool    hadAny       = false;
        byte    shortestMask = 128;
        UInt128 final        = UInt128.MaxValue;

        foreach (IpAddressNetworkV6 other in others)
        {
            final &= other._networkAddress.Address;

            byte lowestCommon = BitUtilities.FindCommonPrefixSize(final, other._networkAddress.Address);
            shortestMask = Math.Min(shortestMask, lowestCommon);

            hadAny = true;
        }

        if (!hadAny)
        {
            throw new ArgumentException("Input was empty", nameof(others));
        }

        return(new IpAddressNetworkV6(new IpAddressV6(final), shortestMask));
    }
コード例 #27
0
    public static IpAddressNetworkV4 MakeSupernet(IEnumerable <IpAddressNetworkV4> others)
    {
        byte shortestMask = 32;
        bool hadAny       = false;
        uint final        = uint.MaxValue;

        foreach (IpAddressNetworkV4 range in others)
        {
            final &= range._networkAddress.Address;

            byte lowestCommon = BitUtilities.FindCommonPrefixSize(final, range._networkAddress.Address);
            shortestMask = Math.Min(shortestMask, lowestCommon);

            hadAny = true;
        }

        if (!hadAny)
        {
            throw new ArgumentException("Input was empty", nameof(others));
        }

        return(new IpAddressNetworkV4(final, shortestMask));
    }
コード例 #28
0
        public static void SerializeGivenChangeMask(
            BinaryWriter writer, NetworkedComponentTypeInfo networkedComponentTypeInfo,
            object value, uint changeMask
            )
        {
            uint changeMaskBitIndex = 0;

            foreach (var field in networkedComponentTypeInfo.ThingsToSynchronize)
            {
                if (BitUtilities.GetBit(changeMask, (byte)changeMaskBitIndex))
                {
                    object fieldValue;
                    Type   fieldType;

                    if (field.FieldInfo != null)
                    {
                        fieldValue = field.FieldInfo.GetValue(value);
                        fieldType  = field.FieldInfo.FieldType;
                    }
                    else if (field.PropertyInfo != null)
                    {
                        fieldValue = field.PropertyInfo.GetValue(value);
                        fieldType  = field.PropertyInfo.PropertyType;
                    }
                    else
                    {
                        throw new Exception("Invalid field to synchronize.");
                    }

                    SerializeObject(
                        writer, fieldValue, fieldType,
                        field.IsNullableIfReferenceType, field.AreElementsNullableIfReferenceType
                        );
                }
                changeMaskBitIndex++;
            }
        }
コード例 #29
0
        public CodingTableStreamer(Dictionary <int, Fraction> frequencyDictionary)
        {
            int largestNumberBitsSymbol    = 0,
                largestNumberBitsFrequency = 0;

            foreach (KeyValuePair <int, Fraction> pair in frequencyDictionary)
            {
                int numBitsSymbol    = BitUtilities.GetNumberBitsToRepresent(pair.Key);
                int numBitsFrequency = BitUtilities.GetNumberBitsToRepresent(pair.Value.Numerator);
                if (numBitsSymbol > largestNumberBitsSymbol)
                {
                    largestNumberBitsSymbol = numBitsSymbol;
                }
                if (numBitsFrequency > largestNumberBitsFrequency)
                {
                    largestNumberBitsFrequency = numBitsFrequency;
                }
                NumFrequencies++;
            }
            LargestSymbolBits = largestNumberBitsSymbol;
            CalculateType();
            LargestFrequencyBits = largestNumberBitsFrequency;
            FreqDict             = frequencyDictionary;
        }
コード例 #30
0
 /// <summary>
 /// Decode value of the immediateSwitch
 /// </summary>
 /// <param name="inputBits">our instruction</param>
 private void DecodeImmediateSwitch(int inputBits)
 {
     immediateSwitchValue = BitUtilities.MaskInput(inputBits, immediateSwitchStartBit, immediateSwitchEndBit);
 }