/*

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

using System.Collections;

using System.Collections.Generic;

using SymbolLib.CodeSegDef;

using SymbolLib.Generics;

using SymbolLib.Sources.Map.Symbol;

using SymbianUtils.Range;

namespace SymbolLib.Sources.Map.File

{

	internal class MapFile : GenericSymbolCollection

    {

        #region Static constructors

        public static MapFile NewByHostMapFileName( string aMapFileNameAndPath )

        {

            // The specified file should end in .map

            System.Diagnostics.Debug.Assert( aMapFileNameAndPath.ToUpper().EndsWith( ".MAP" ) );

            // Get rid of map file extension.

            string binaryFileName = aMapFileNameAndPath.Substring( 0, aMapFileNameAndPath.Length - 4 );

            MapFile ret = new MapFile( binaryFileName, aMapFileNameAndPath );

            return ret;

        }

        #endregion

        #region Constructors

        private MapFile( string aHostBinaryName, string aHostMapFileName )

            : base( aHostBinaryName )

        {

            base.SourceFile = aHostMapFileName;

            // Make the dummy entry in case we obtain no further symbols

            MapSymbol dummy = MapSymbol.NewUnknown( this );

            iEntries.Add( dummy );

        }

        #endregion

        #region API

        public void EnsureAllEntriesHaveSize()

        {

            int count = Count;

#if DEBUG

            // Debug support

            int x = 0;

            if ( x != 0 )

            {

                string line = string.Empty;

                for ( int i = 0; i < count; i++ )

                {

                    GenericSymbol entry = iEntries[ i ];

                    line = i.ToString( "d8" ) + "   [" + entry.Address.ToString( "x8" ) + "-" + entry.EndAddress.ToString( "x8" ) + "] " + entry.Symbol.ToString();

                    System.Diagnostics.Debug.WriteLine( line );

                }

            }

#endif

            // Now go through the entries and update their sizes (if they don't have one)

            for ( int i = 1; i < count; i++ )

            {

                GenericSymbol entry = iEntries[ i ];

                GenericSymbol previousEntry = iEntries[ i - 1 ];

                //

                if  ( previousEntry.Size == 0 )

                {

                    long calculatedPreviousEntrySize = ( entry.Address - previousEntry.Address ) - 1;

                    if ( calculatedPreviousEntrySize > 0 )

                    {

                        previousEntry.Size = calculatedPreviousEntrySize;

                    }

                }

            }

        }

        public void Fixup( CodeSegDefinition aDefinition )

        {

            // Work out base address offset based upon global address and code segment 

            // placement address.

            uint baseAddress = aDefinition.AddressStart;

            BaseAddress = baseAddress;

            iFixedUpRange = aDefinition.AddressRange;

            base.RebuildAddressRange();

        }

        #endregion

        #region Properties

        public override AddressRange AddressRange

        {

            get { return iFixedUpRange; } 

        }

        internal uint GlobalBaseAddress

        {

            get { return iGlobalBaseAddress; }

            set

            {

                iGlobalBaseAddress = value;

            }

        }

		#endregion

        #region From GenericSymbolCollection

        public override void Add( GenericSymbolEngine aEngine, GenericSymbol aSymbol )

        {

            // We don't take data symbols, just code

            MapSymbol symbol = (MapSymbol) aSymbol;

            MapSymbol.TType type = symbol.Type;

            if ( type == MapSymbol.TType.EThumbCode || type == MapSymbol.TType.EARMCode )

            {

                // Don't take code entries with no size

                if ( aSymbol.Size > 0 )

                {

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

                    // the collection.

                    if ( Count == 1 && this[ 0 ].IsUnknownSymbol )

                    {

                        RemoveAt( 0 );

                    }

                    iEntries.Add( aSymbol );

                }

                else

                {

#if TRACE

                    System.Diagnostics.Debug.WriteLine( "Discarding zero size entry: " + aSymbol.ToString() );

#endif

                }

            }

        }

		public override void Remove( GenericSymbol aSymbol )

		{

			iEntries.Remove( aSymbol );

		}

		public override void RemoveAt( int aIndex )

		{

			iEntries.RemoveAt( aIndex );

		}

        public override void Sort()

        {

            iEntries.Sort( new GenericSymbolComparer() );

        }

        public override int Count

        {

            get { return iEntries.Count; }

        }

        public override System.Collections.IEnumerator CreateEnumerator()

        {

            return new MapFileEnumerator( this );

        }

        public override System.Collections.Generic.IEnumerator<GenericSymbol> CreateGenericEnumerator()

        {

            return new MapFileEnumerator( this );

        }

        public override GenericSymbol this[ int aIndex ]

        {

            get

            {

                return iEntries[ aIndex ];

            }

        }

        public override long AddressRangeStart

		{

            get { return iFixedUpRange.Min; }

		}

		public override long AddressRangeEnd

		{

            get { return iFixedUpRange.Max; }

        }

        public override GenericSymbol SymbolForAddress( long aAddress )

        {

#if DEBUG

            int x = 0;

            if ( x > 0 )

            {

                base.Dump( aAddress );

            }

#endif

            GenericSymbol ret = null;

            //

            foreach ( GenericSymbol symbol in this )

            {

                if ( symbol.FallsWithinDomain( aAddress ) )

                {

                    ret = symbol;

                    break;

                }

            }

            //

            return ret;

        }		

        #endregion

        #region From System.Object

        public override string ToString()

        {

            StringBuilder ret = new StringBuilder();

            ret.Append( iFixedUpRange.ToString() );

            return ret.ToString();

        }

        #endregion

        #region Data members

        private uint iGlobalBaseAddress = 0;

        private AddressRange iFixedUpRange = new AddressRange();

        private List<GenericSymbol> iEntries = new List<GenericSymbol>( 50 );

		#endregion

	}

}