/*
* 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;
using SymbianUtils.BasicTypes;
using SymbianStructuresLib.Arm;
using SymbianStructuresLib.Arm.Exceptions;
using SymbianETMLib.Common.Types;
using SymbianETMLib.Common.Config;
using SymbianETMLib.Common.State;

namespace SymbianETMLib.Common.BranchDecoder
{
    internal class ETMBranchDecoderAlternative : ETMBranchDecoderOriginal
    {
        #region Constructors
        public ETMBranchDecoderAlternative( ETMStateData aManager )
            : base( aManager )
        {
        }
        #endregion

        #region From ETBBranchDecoder
        protected override void DecodePartial()
        {
            int count = base.Count;
            System.Diagnostics.Debug.Assert( count > 0 && count < 5 );

            // According to Table 7-13, "Missing components of exception Branch address packets"
            // then after a partial branch, we're always in "no exception" state
            base.ExceptionType = TArmExceptionType.ENone;

            if ( count == 1 )
            {
                // The single-byte packet is exactly the same as in the original encoding
                base.DecodePartial();
            }
            else
            {
                // We have full 5 bytes of address info.
                SymMask maskFirst = new SymMask( 0x7E, SymMask.TShiftDirection.ERight, 1 );
                SymMask maskMiddle = new SymMask( 0x7F );
                SymMask maskLast = new SymMask( 0x3F );

                SymByte b;
                SymAddressWithKnownBits address = new SymAddressWithKnownBits();
                uint masked = 0;

                // First byte
                b = base[ 0 ];
                address.KnownBits += 6;
                address.Address |= maskFirst.Apply( b );

                // Middle bytes, but not the last
                for ( int i = 1; i < count-1; i++ )
                {
                    b = base[ i ];
                    b = (byte) maskMiddle.Apply( b );
                    masked = (uint) ( b << address.KnownBits );
                    address.KnownBits += 7;
                    address.Address |= masked;
                }

                // Last byte
                b = base.LastByte;
                address.KnownBits += 6;
                address.Address |= maskLast.Apply( b );

                // Shift entire address by shift count based upon current instruction set.
                int isShift = ETMBranchDecoder.CompressionLeftShiftCount( base.InstructionSet );
                address.KnownBits += isShift;
                address.Address <<= isShift;

                // Save address
                base.BranchAddress = address;
            }
        }

        public override bool IsPacketComplete
        {
            get
            {
                bool ret = false;
                //
                SymByte lastByte = base.LastByte;
                bool bit7 = lastByte[ 7 ];
                //
                if ( bit7 )
                {
                    // If the 7th bit is set, then the interpretation is the same as in the original
                    // compression scheme, in which case we can use the base class call.
                    ret = base.IsPacketComplete;
                }
                else
                {
                    if ( base.Count == 1 )
                    {
                        // If the 7th bit is clear and this is the first byte, then this is also
                        // the only byte - no exception continuation byte follows.
                        ret = true;
                    }
                    else
                    {
                        // If the 7th bit is clear and the 6th bit is also clear, then this is
                        // the last byte.
                        bool bit6 = lastByte[ 6 ];
                        ret = ( bit6 == false );
                    }
                }
                //
                return ret;
            }
        }

        public override bool IsBranchAddressAvailable
        {
            get
            {
                bool ret = base.IsBranchAddressAvailable;
                return ret;
            }
        }
        #endregion

        #region From ETBBranchDecoderOriginal
        /*
        protected override bool ContainsInlineException
        {
            get
            {
                // Not supported in alternative encoding
                return false;
            }
        }*/
        #endregion

        #region Properties
        #endregion

        #region Internal constants
        #endregion

        #region Internal methods
        #endregion

        #region Data members
        #endregion
    }
}