/*

* 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.IO;

using System.Collections;

using System.Collections.Generic;

using SymbianUtils;

using SymbianUtils.Range;

using SymbolLib.Generics;

using SymbolLib.Sources.Symbol.Symbol;

namespace SymbolLib.Sources.Symbol.File

{

    public class SymbolsForBinary : GenericSymbolCollection

	{

		#region Construct & destruct

        public SymbolsForBinary( string aHostFileName )

            : base( aHostFileName )

		{

            // Add default unknown entry

            SymbolSymbol nullEntry = SymbolSymbol.NewUnknown( this );

            iEntries.Add( nullEntry );

		}

		#endregion

        #region Properties

        internal GenericSymbol InternalLastSymbol

        {

            get

            {

                // We don't want to return the last symbol

                GenericSymbol ret = base.LastSymbol;

                //

                if ( ret != null && ret.IsUnknownSymbol )

                {

                    ret = null;

                }

                //

                return ret;

            }

        }

        #endregion

        #region API

        internal void Add( GenericSymbolEngine aEngine, GenericSymbol aSymbol, bool aAllowNonRomSymbols )

        {

            System.Diagnostics.Debug.Assert( aSymbol is SymbolSymbol );

            // Check for Image$$ER_RO$$Base or Image$$ER_RO$$Limit. 

            // This symbol is emitted for user-side code and can be used to work around some maksym problems.

            string symbolName = aSymbol.Symbol;

            if ( symbolName.StartsWith( KSymbolNameImageBaseOrLimitPrefix ) )

            {

                bool isBase = symbolName.Contains( "Base" );

                // If we've just seen the base entry, but we already have some stored symbols, then

                // probably this is a maksym problem that we must try to work around.

                if ( isBase )

                {

                    int count = iEntries.Count;

                    if ( count > 0 && !iEntries[ 0 ].IsUnknownSymbol )

                    {

                        // Discard all the entries we've seen so far because most likely

                        // they are invalid.

                        System.Diagnostics.Debug.WriteLine( string.Format( "Discarding {0} invalid symbols for library: {1}", count, base.HostBinaryFileName ) );

                        iEntries.Clear();

                        // At this point, we need to reset the base address because any symbols that have gone 

                        // before are invalid.

                        iFlags &= ~TFlags.EFlagsHaveSeenFirstSymbol;

                    }

                }

                else

                {

                    // Reached the limit - stop storing symbols at this point as everything else is likely data.

                    iFlags |= TFlags.EFlagsDisallowFurtherSymbolsForCollection;

                }

            }

            // Don't save the entry if we're in disabled state.

            bool newAdditionsDisabled = ( iFlags & TFlags.EFlagsDisallowFurtherSymbolsForCollection ) == TFlags.EFlagsDisallowFurtherSymbolsForCollection;

            if ( !newAdditionsDisabled )

            {

                // Whether or not we keep the entry

                bool addEntry = false;

                // Set base address

                UpdateCollectionBaseAddressBasedUponFirstSymbol( aSymbol );

                GenericSymbol lastSymbol = InternalLastSymbol;

                if ( lastSymbol != null )

                {

                    if ( lastSymbol.Address > aSymbol.Address )

                    {

                        // Work-around for maksym problem where it fails to parse some MAP files correctly.

                    }

                    else

                    {

                        // If we have a last symbol, and it's address is prior to that of the new symbol, we can

                        // try to update the last symbol's size (if it needs it updating - the method will check that).

                        UpdateLengthOfPreviousSymbol( aSymbol );

                        // Check to see if we already have a symbol within this address range

                        bool overlappingSymbol = LastSymbolSharesSameAddressRange( aSymbol );

                        if ( overlappingSymbol )

                        {

                            // They overlap - which one do we keep? 

                            addEntry = FilterOutCommonAddressEntry( lastSymbol, aSymbol );

                        }

                        else

                        {

                            addEntry = TakeEntry( aSymbol, aAllowNonRomSymbols );

                        }

                    }

                }

                else

                {

                    addEntry = TakeEntry( aSymbol, aAllowNonRomSymbols );

                }

                // If we need to keep the symbol, then save it now...

                if ( addEntry )

                {

                    DoAddEntry( aSymbol );

                }

            }

        }

        internal void Fixup( long aNewBaseAddress )

        {

            BaseAddress = aNewBaseAddress;

            if ( aNewBaseAddress != 0 )

            {

                iFlags |= TFlags.EFlagsHaveDoneFixup;

            }

            base.RebuildAddressRange();

        }

        #endregion

        #region From GenericSymbolCollection

        public override void WriteToStream( StreamWriter aWriter )

        {

            if ( ( iFlags & TFlags.EFlagsHaveDoneFixup ) == TFlags.EFlagsHaveDoneFixup )

            {

                long originalBaseAddress = BaseAddress;

                try

                {

                    // For fixed up symbol collections, i.e. those with a base address of zero

                    // that have subsequently been fixed up at runtime (rofs) then we

                    // must ensure we write base addresses of zero again when externalising

                    // the symbol data.

                    BaseAddress = 0;

                    base.WriteToStream( aWriter );

                }

                finally

                {

                    BaseAddress = originalBaseAddress;

                }

            }

            else

            {

                base.WriteToStream( aWriter );

            }

        }

        public override void Add( GenericSymbolEngine aEngine, GenericSymbol aSymbol )

        {

            Add( aEngine, aSymbol, true );

        }

		public override void Remove( GenericSymbol aSymbol )

		{

			iEntries.Remove( aSymbol );

		}

		public override void RemoveAt( int aIndex )

		{

			iEntries.RemoveAt( aIndex );

		}

        public override int Count

        {

            get

            {

                return iEntries.Count;

            }

        }

        public override void Sort()

        {

            iEntries.Sort( new GenericSymbolComparer() );

#if PROFILING

            System.DateTime startTime = DateTime.Now;

            System.DateTime endTime = DateTime.Now;

            long tickDuration = ( ( endTime.Ticks - startTime.Ticks ) / 100 );

            System.Diagnostics.Debug.WriteLine( "SORT TIME " + tickDuration.ToString( "d6" ) );

#endif

        }

        public override GenericSymbol SymbolForAddress( long aAddress )

        {

#if DEBUG

            int x = 0;

            if ( x > 0 )

            {

                base.Dump( aAddress );

            }

#endif

            GenericSymbol ret = null;

            //

            AddressFindingComparer comparer = new AddressFindingComparer();

            SymbolSymbol temp = SymbolSymbol.NewUnknown( (uint) aAddress, 0, string.Empty );

            int pos = iEntries.BinarySearch( temp, comparer );

            if ( pos >= 0 && pos < iEntries.Count )

            {

                ret = iEntries[ pos ];

                System.Diagnostics.Debug.Assert( ret.AddressRange.Contains( aAddress ) );

            }

            //

            return ret;

        }

        public override IEnumerator CreateEnumerator()

        {

            IEnumerator<GenericSymbol> self = (IEnumerator<GenericSymbol>) this;

            return self;

        }

        public override IEnumerator<GenericSymbol> CreateGenericEnumerator()

        {

            foreach ( GenericSymbol sym in iEntries )

            {

                yield return sym;

            }

        }

        public override GenericSymbol this[ int aIndex ]

        {

            get

            {

                return iEntries[ aIndex ];

            }

        }

        #endregion

        #region Internal enumerations

        [Flags]

		private enum TFlags

		{

			EFlagsNone = 0,

			EFlagsCalculateLengthOfPreviousSymbol = 1,

			EFlagsDisallowFurtherSymbolsForCollection = 2,

			EFlagsHaveSeenFirstSymbol = 4,

            EFlagsHaveDoneFixup = 8

		}

		#endregion

        #region Internal constants

        private const string KSymbolNameImageBaseOrLimitPrefix = "Image$$ER_RO$$";

        private const long KMaxDifferenceBetweenConsecutiveSymbols = 1024 * 64;

        #endregion

        #region Internal methods

        private void UpdateCollectionBaseAddressBasedUponFirstSymbol( GenericSymbol aSymbol )

        {

            // If we are not processing the first Symbol in the collection, then we

            // can rely on the base address being set. Otherwise, we are

            // defining the base address itself.

            if ( !( ( iFlags & TFlags.EFlagsHaveSeenFirstSymbol ) == TFlags.EFlagsHaveSeenFirstSymbol ) )

            {

                // Set collection base address to symbol starting address

                BaseAddress = aSymbol.Address;

                // Since this is the first symbol in the collection, and we're going to use

                // its address as the offset (base) address for the entire collection, 

                // if we just set the collection base address to the symbol's address and

                // the continue, this entry will be double offset (the new offset for the collection

                // + the offset of the symbol itself). We must therefore set the symbol's offset

                // address to zero.

                SymbolSymbol realSymbol = (SymbolSymbol) aSymbol;

                realSymbol.ResetOffsetAddress( 0 );

                // Make sure we set a flag so that we don't attempt to do this again.

                iFlags |= TFlags.EFlagsHaveSeenFirstSymbol;

            }

        }

        private void UpdateLengthOfPreviousSymbol( GenericSymbol aNewSymbol )

        {

            bool clearFlag = false;

            //

            if ( ( iFlags & TFlags.EFlagsCalculateLengthOfPreviousSymbol ) == TFlags.EFlagsCalculateLengthOfPreviousSymbol )

            {

                // Must have some existing symbol.

                System.Diagnostics.Debug.Assert( Count > 0 );

                // Last symbol must have bad size?

                GenericSymbol previousSymbol = InternalLastSymbol;

                System.Diagnostics.Debug.Assert( previousSymbol.Size == 0 );

                // The new symbol must be exactly the same address as the last symbol

                // (in which case, the new symbol must have a valid size or else we're

                // unable to do anything sensible with it) 

                //

                // OR

                //

                // The new symbol must be after the last symbol. It cannot be before.

                System.Diagnostics.Debug.Assert( aNewSymbol.Address >= previousSymbol.Address );

                if ( aNewSymbol.Address == previousSymbol.Address )

                {

                    if ( aNewSymbol.Size > 0 )

                    {

                        // Okay, the new symbol has a valid size, the old one didn't.

                        clearFlag = true;

                        previousSymbol.Size = aNewSymbol.Size;

                    }

                    else

                    {

                        // Hmm, neither the last or new symbol have a valid size.

                        // Nothing we can do in this case...

                    }

                }

                else

                {

                    // Need to work out the length of the previous symbol by comparing the

                    // address of this symbol against it.

                    //

                    // Only do this if the region type hasn't changed.

                    MemoryModel.TMemoryModelRegion previousType = MemoryModel.RegionByAddress( previousSymbol.Address, aNewSymbol.MemoryModelType );

                    MemoryModel.TMemoryModelRegion regionType = MemoryModel.RegionByAddress( aNewSymbol.Address, aNewSymbol.MemoryModelType );

                    if ( regionType == previousType )

                    {

                        // If this new symbol and the old symbol have the same address, then

                        // also check the size of the previous symbol. If it was zero, then discard it

                        // and keep this new entry. Otherwise, discard this new one instead.

                        long delta = aNewSymbol.Address - previousSymbol.Address;

                        if ( delta > 1 )

                        {

                            // It's okay, this symbol had a later address than the last one

                            // This is normal.

                            previousSymbol.Size = delta;

                        }

                        else

                        {

                            // This is not good. Two symbols both have the same address.

                            iEntries.Remove( previousSymbol );

                        }

                    }

                    clearFlag = true;

                }

            }

            if ( clearFlag )

            {

                iFlags &= ~TFlags.EFlagsCalculateLengthOfPreviousSymbol;

            }

        }

        private void DoAddEntry( GenericSymbol aSymbol )

        {

            // Make sure we remove the null symbol if this is the first 'valid' symbol for

            // the collection.

            if ( OnlyContainsDefaultSymbol )

            {

                RemoveAt( 0 );

            }

            // If the symbol has no size, then try to work it out next time around

            if ( aSymbol.Size == 0 )

            {

                iFlags |= TFlags.EFlagsCalculateLengthOfPreviousSymbol;

            }

            // Save it

            iEntries.Add( aSymbol );

        }

        private bool LastSymbolSharesSameAddressRange( GenericSymbol aSymbol )

        {

            bool ret = false;

            //

            GenericSymbol last = InternalLastSymbol;

            if ( last != null && last.FallsWithinDomain( aSymbol.Address ) )

            {

                ret = true;

            }

            //

            return ret;

        }

        private bool FilterOutCommonAddressEntry( GenericSymbol aLast, GenericSymbol aNew )

        {

            bool acceptNew = false;

            //

            if ( aLast.IsUnknownSymbol )

            {

                // Always discard the unknown symbol in preference of anything better

                iEntries.Remove( aLast );

                acceptNew = true;

            }

            else if ( aNew.Size > 0 )

            {

                if ( aLast.Size == 0 )

                {

                    // New is 'better' because it contains proper sizing information

                    iEntries.Remove( aLast );

                    acceptNew = true;

                }

                else if ( aLast.Size < aNew.Size )

                {

                    // New is 'better' because it is bigger

                    iEntries.Remove( aLast );

                    acceptNew = true;

                }

                else if ( aLast.Size == aNew.Size )

                {

                    // Both the same size. Take symbols over everything else.

                    if ( aNew.IsSymbol && !aLast.IsSymbol )

                    {

                        // Keep the symbol (new)

                        iEntries.Remove( aLast );

                        acceptNew = true;

                    }

                    else if ( !aNew.IsSymbol && aLast.IsSymbol )

                    {

                        // Keep the symbol (last)

                        acceptNew = false;

                    }

                    else

                    {

                        // Take higher priority...

                        if ( aNew.AddressType > aLast.AddressType )

                        {

                            iEntries.Remove( aLast );

                            acceptNew = true;

                        }

                        else

                        {

                            acceptNew = false;

                        }

                    }

                }

            }

            else if ( aLast.Size > 0 )

            {

                // Last is 'better' because the new entry doesn't have any size

                acceptNew = false;

            }

            else if ( aLast.Size == 0 && aNew.Size == 0 )

            {

                // Both entries have no size and the same address. We cannot

                // accept both, therefore we make an arbitrary decision about

                // which to keep.

                if ( aLast.IsSubObject && !aNew.IsSubObject )

                {

                    // Discard the sub object (last)

                    iEntries.Remove( aLast );

                    acceptNew = true;

                }

                else if ( aNew.IsSubObject && !aLast.IsSubObject )

                {

                    // Discard the sub object (new)

                    acceptNew = false;

                }

                else if ( aNew.IsSymbol && !aLast.IsSymbol )

                {

                    // Keep the symbol (new)

                    iEntries.Remove( aLast );

                    acceptNew = true;

                }

                else if ( !aNew.IsSymbol && aLast.IsSymbol )

                {

                    // Keep the symbol (last)

                    acceptNew = false;

                }

                else

                {

                    // Couldn't make a good decision. Junk the new entry

                    acceptNew = false;

                }

            }

            //

            return acceptNew;

        }

        private bool IsEntryReallyData( GenericSymbol aSymbol )

        {

            bool isData = false;

            // Check to see if its from a data=<something> IBY entry...

            string baseName = Path.GetFileName( HostBinaryFileName ).ToLower();

            string symbolName = aSymbol.Symbol.ToLower();

            if ( symbolName == baseName && aSymbol.Size == 0 )

            {

                // Its from a data entry

                isData = true;

                // Data entries only consist of a single symbol (the data itself)

                iFlags |= TFlags.EFlagsDisallowFurtherSymbolsForCollection;

            }

            return isData;

        }

        private bool TakeEntry( GenericSymbol aSymbol, bool aAllowNonRomSymbols )

        {

            bool take = IsEntryReallyData( aSymbol );

            if ( !take )

            {

                // We'll take the entry if all we have at the moment is

                // the default entry or then no entries at all.