diff -r 000000000000 -r 818e61de6cd1 crashanalysercmd/PerfToolsSharedLibraries/Engine/SymbianUtils/BasicTypes/SymUInt.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/crashanalysercmd/PerfToolsSharedLibraries/Engine/SymbianUtils/BasicTypes/SymUInt.cs Thu Feb 11 15:50:58 2010 +0200 @@ -0,0 +1,415 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SymbianUtils.BasicTypes +{ + public class SymUInt32 : SymUIntBase + { + #region Constructors + public SymUInt32( uint aValue ) + : base( aValue, 32 ) + { + } + + public SymUInt32( string aBinary ) + : base( aBinary, 32 ) + { + } + #endregion + + #region Operators + public static SymUInt32 operator &( SymUInt32 aLeft, SymUInt32 aRight ) + { + uint val = aLeft.RawValue & aRight.RawValue; + return new SymUInt32( val ); + } + + public static implicit operator SymUInt32( uint aBasicType ) + { + return new SymUInt32( aBasicType ); + } + #endregion + } + + public class SymUInt16 : SymUIntBase + { + #region Constructors + public SymUInt16( ushort aValue ) + : base( aValue, 16 ) + { + } + + public SymUInt16( string aBinary ) + : base( aBinary, 16 ) + { + } + #endregion + + #region Operators + public static SymUInt16 operator &( SymUInt16 aLeft, SymUInt16 aRight ) + { + ushort val = Convert.ToUInt16( aLeft.RawValue & aRight.RawValue ); + return new SymUInt16( val ); + } + public static implicit operator SymUInt16( ushort aBasicType ) + { + return new SymUInt16( aBasicType ); + } + #endregion + } + + public class SymUInt8 : SymUIntBase + { + #region Constructors + public SymUInt8( byte aValue ) + : base( aValue, 8 ) + { + } + + public SymUInt8( string aBinary ) + : base( aBinary, 8 ) + { + } + #endregion + + #region Operators + public static SymUInt8 operator &( SymUInt8 aLeft, SymUInt8 aRight ) + { + byte val = Convert.ToByte( aLeft.RawValue & aRight.RawValue ); + return new SymUInt8( val ); + } + + public static implicit operator SymUInt8( byte aBasicType ) + { + return new SymUInt8( aBasicType ); + } + #endregion + } + + public abstract class SymUIntBase : IFormattable + { + #region Constructors + protected SymUIntBase() + { + } + + protected SymUIntBase( string aBinary, int aNumberOfBits ) + { + iValue = SymBitUtils.CreateMask( aBinary ); + iNumberOfBits = aNumberOfBits; + } + + protected SymUIntBase( uint aValue, int aNumberOfBits ) + { + iValue = aValue; + iNumberOfBits = aNumberOfBits; + } + #endregion + + #region API + public bool IsMatch( string aBinary ) + { + uint value = 0; + uint mask = SymBitUtils.CreateMask( aBinary, out value ); + bool ret = ( mask & iValue ) == value; + return ret; + } + + public uint RShift( int aBits ) + { + uint v = iValue; + v >>= aBits; + this.RawValue = v; + return v; + } + + public uint LShift( int aBits ) + { + uint v = (uint) ( iValue << aBits ); + this.RawValue = v; + return v; + } + + public SymUInt32 RotateRight( int aCount ) + { + uint ret = iValue; + // + for ( int i = 0; i < aCount; i++ ) + { + bool bitZeroSet = ( ( ret & 0x1 ) == 0x1 ); + ret >>= 1; + // + if ( bitZeroSet ) + { + // Wrap the bit around by appling it at the top end + ret |= KTopBit; + } + } + // + return new SymUInt32( ret ); + } + + public uint ToUInt() + { + return iValue; + } + #endregion + + #region Properties + public int NumberOfBits + { + get { return iNumberOfBits; } + protected set + { + switch ( value ) + { + default: + throw new ArgumentException( "Number of bits must be 8, 16 or 32" ); + case 8: + case 16: + case 32: + iNumberOfBits = value; + break; + } + } + } + + public int NumberOfBytes + { + get { return NumberOfBits / 4; } + set + { + this.NumberOfBits = value * 8; + } + } + + public uint MaxValue + { + get + { + uint ret = uint.MaxValue; + if ( iNumberOfBits == 16 ) + { + ret = ushort.MaxValue; + } + else if ( iNumberOfBits == 8 ) + { + ret = byte.MaxValue; + } + return ret; + } + } + + public string Binary + { + get + { + string bits = SymBitUtils.BeautifyBits( iValue, iNumberOfBits ); + return bits; + } + } + + public string Hex + { + get + { + string hex = iValue.ToString( string.Format( "x{0}", this.NumberOfBytes * 2 ) ); + return hex; + } + } + + public SymBit this[ int aIndex ] + { + get + { + if ( aIndex < 0 || aIndex > iNumberOfBits ) + { + throw new ArgumentException( "Specified bit is out of bounds" ); + } + + uint mask = ( 1u << aIndex ); + SymBit ret = ( ( mask & iValue ) == mask ) ? SymBit.ESet : SymBit.EClear; + return ret; + } + } + + public SymUInt32 this[ int aHighBitIndex, int aLowBitIndex ] + { + get + { + if ( aHighBitIndex < aLowBitIndex ) + { + throw new ArgumentException( "High bit index must be less than low bit index" ); + } + + // Build mask + uint mask = 0; + for ( int i = aLowBitIndex; i <= aHighBitIndex; i++ ) + { + mask |= ( 1u << i ); + } + + uint ret = iValue & mask; + + // Shift + ret >>= aLowBitIndex; + + return new SymUInt32( ret ); + } + } + #endregion + + #region Operators + public static implicit operator uint( SymUIntBase aObject ) + { + return aObject.RawValue; + } + + public static implicit operator ushort( SymUIntBase aObject ) + { + ushort ret = Convert.ToUInt16( aObject.RawValue ); + return ret; + } + + public static implicit operator byte( SymUIntBase aObject ) + { + byte ret = Convert.ToByte( aObject.RawValue ); + return ret; + } + + public static bool operator ==( SymUIntBase aLeft, SymUIntBase aRight ) + { + // If both are null, or both are same instance, return true. + if ( System.Object.ReferenceEquals( aLeft, aRight ) ) + { + return true; + } + + // If one is null, but not both, return false. + if ( ( (object) aLeft == null ) || ( (object) aRight == null ) ) + { + return false; + } + + bool ret = aLeft.Equals( aRight ); + return ret; + } + + public static bool operator !=( SymUIntBase aLeft, SymUIntBase aRight ) + { + bool result = !( aLeft == aRight ); + return result; + } + + public static SymUInt32 operator &( SymUIntBase aLeft, SymUIntBase aRight ) + { + uint val = ( aLeft.RawValue & aRight.RawValue ); + return new SymUInt32( val ); + } + #endregion + + #region IFormattable Members + public string ToString( string aFormat, IFormatProvider aFormatProvider ) + { + if ( aFormatProvider != null ) + { + ICustomFormatter formatter = aFormatProvider.GetFormat( this.GetType() ) as ICustomFormatter; + if ( formatter != null ) + { + return formatter.Format( aFormat, this, aFormatProvider ); + } + } + + string ret = string.Empty; + string format = aFormat != null ? aFormat : "full"; + // + switch ( format ) + { + case "full": + ret = string.Format( "0x{0} [{1}]", Hex, Binary ); + break; + default: + ret = iValue.ToString( aFormat, aFormatProvider ); + break; + } + // + return ret; + } + #endregion + + #region From System.Object + public override string ToString() + { + return ToString( null ); + } + + public string ToString( string aFormat ) + { + return ToString( aFormat, null ); + } + + public override bool Equals( object aObject ) + { + bool ret = false; + // + if ( aObject != null && aObject is SymUIntBase ) + { + SymUIntBase other = (SymUIntBase) aObject; + // + if ( other.NumberOfBits == this.NumberOfBits ) + { + ret = ( other.RawValue == this.RawValue ); + } + } + // + return ret; + } + + public override int GetHashCode() + { + return iValue.GetHashCode(); + } + #endregion + + #region Internal properties & methods + protected uint RawValue + { + get { return iValue; } + set + { + if ( value > MaxValue ) + { + throw new ArgumentException( string.Format( "Specified value {0} exceeds bit range ({1})", value, this.NumberOfBits ) ); + } + iValue = value; + } + } + #endregion + + #region Internal constants + private const uint KTopBit = 0x80000000; + #endregion + + #region Data ember + private uint iValue = 0; + private int iNumberOfBits = 32; + #endregion + } +}