/*

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

using System.Text;

using System.Text.RegularExpressions;

using SymbianUtils.Range;

using SymbianUtils;

namespace SymbolLib.Generics

{

    #region Exception

	public class GenericSymbolicCreationException : Exception

	{

	}

    #endregion

	public abstract class GenericSymbol

	{

		#region Enumerations

		public enum TAddressType

		{

            // Do not change the order - these are priority based with

            // the most important symbol type appearing with a larger

            // value

			EAddressTypeUnknown = -1,

            EAddressTypeReadOnlySymbol = 0,

			EAddressTypeKernelGlobalVariable,

            EAddressTypeSubObject,

            EAddressTypeLabel,

			EAddressTypeRAMSymbol,

            EAddressTypeROMSymbol,

		}

        public enum TSourceType

        {

            ESourceTypeFileSymbol = 0,

            ESourceTypeFileMap

        }

        public enum TInstructionSet

        {

            EInstructionSetARM = 0,

            EInstructionSetTHUMB

        }

		#endregion

        #region Public constants

        public const int KNullEntryAddress = 0;

        public const string KNonMatchingObjectName = "Unknown Object";

        public const string KNonMatchingSymbolName = "Unknown Symbol";

        #endregion

        #region Constructors

        protected GenericSymbol( GenericSymbolCollection aCollection )

		{

            iCollection = aCollection;

		}

		#endregion

		#region Abstract API

        public abstract TSourceType SourceType { get; }

		public abstract bool Parse( string aLine );

		#endregion

		#region Framework API

		public virtual bool FallsWithinDomain(long aAddress)

		{

			return (aAddress >= Address && aAddress <= EndAddress);

		}

		public virtual bool IsSubObject

		{

			get

			{

				bool ret = ( AddressType == TAddressType.EAddressTypeSubObject );

				return ret;

			}

		}

		public virtual bool IsLabel

		{

			get

			{

				bool ret = ( AddressType == TAddressType.EAddressTypeLabel );

				return ret;

			}

		}

		public virtual bool IsSymbol

		{

			get

			{

				bool ret = ( Collection.BaseAddress == 0 || AddressType == TAddressType.EAddressTypeRAMSymbol || AddressType == TAddressType.EAddressTypeROMSymbol );

				return ret;

			}

		}

		public virtual MemoryModel.TMemoryModelType MemoryModelType // Guess

		{

			get

			{

				return iStaticMemoryModelType;

			}

		}

		public virtual TAddressType AddressType

		{

			get

			{

				TAddressType ret = TAddressType.EAddressTypeUnknown;

				if	( Address >= 0xF8000000 && Address < 0xFFEFFFFF )

				{

					// ROM Symbol, Moving Memory Model

					ret = TAddressType.EAddressTypeROMSymbol;

				}

				else if ( Address >= 0xF4000000 && Address < 0xF7FFFFFF )

				{

					// RAM Symbol, Moving Memory Model

					ret = TAddressType.EAddressTypeRAMSymbol;

				}

				else if ( Address >= 0x64000000 && Address < 0x64FFFFFF )

				{

					// Kernel global, Moving Memory Model

					ret = TAddressType.EAddressTypeKernelGlobalVariable;

				}

				else if ( Address >= 0xc8000000 && Address < 0xC8FFFFFF)

				{

					// Kernel global, Multiple Memory Model

					ret = TAddressType.EAddressTypeKernelGlobalVariable;

				}

				else if ( Address >= 0x80000000 && Address < 0x8FFFFFFF )

				{

					// ROM Symbol, Multiple Memory Model

					ret = TAddressType.EAddressTypeROMSymbol;

				}

				else if ( Address >= 0x3C000000 && Address < 0x3DFFFFFF )

				{

					// RAM Symbol, Moving Memory Model [1gb]

					ret = TAddressType.EAddressTypeRAMSymbol;

				}

				else if ( Address >= 0x70000000 && Address < 0x7FFFFFFF )

				{

					// RAM Symbol, Moving Memory Model [2gb]

					ret = TAddressType.EAddressTypeRAMSymbol;

				}

                else if ( Address < 0x10000000 )

                {

                    // A non-fixed up ROFS symbol entry

                    ret = TAddressType.EAddressTypeRAMSymbol;

                }

				// These can over-ride the previous items...

				if	( iSymbol.IndexOf("Image$$ER_RO$$") >= 0 )

				{

					ret = TAddressType.EAddressTypeReadOnlySymbol;

				}

				else if ( iSymbol.IndexOf("__sub_object(") > 0 )

				{

					ret = TAddressType.EAddressTypeSubObject;

				}

				else if ( ret != TAddressType.EAddressTypeKernelGlobalVariable )

				{

                    bool containsBrackets = iSymbol.Contains( "(" ) && iSymbol.Contains( ")" );

                    if ( !containsBrackets )

                    {

                        ret = TAddressType.EAddressTypeLabel;

                    }

				}

				return ret;

			}

		}

		#endregion

        #region API

        public static string UnknownOffset()

        {

            string text = "[+ ??????]";

            return text;

        }

        public uint Offset( uint aInstructionAddress )

        {

            uint baseAddressOffset = aInstructionAddress - System.Convert.ToUInt32( Address );

            return baseAddressOffset;

        }

        public string OffsetAsString( uint aInstructionAddress )

        {

            uint baseAddressOffset = Offset( aInstructionAddress );

            string text = "[+ 0x" + baseAddressOffset.ToString( "x4" ) + "]";

            return text;

        }

        #endregion

        #region Properties

        public TInstructionSet InstructionSet

        {

            get

            {

                TInstructionSet ret = TInstructionSet.EInstructionSetARM;

                //

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

                {

                    ret = TInstructionSet.EInstructionSetTHUMB;

                }

                //

                return ret;

            }

        }

        public long BaseAddress

        {

            get { return iCollection.BaseAddress; }

        }

		public long Address

		{

			get

            {

                long address = BaseAddress + iOffsetAddress;

                return address;

            }

		}

		public long EndAddress

		{

			get

            {

                long ret = BaseAddress + iOffsetEndAddress;

                return ret;

            }

		}

		public long Size

		{

			get { return iSize; }

			set

			{

				System.Diagnostics.Debug.Assert( value >= 0 );

				iSize = value;

                // We need to update the end address

                if ( iSize > 0 )

                {

                    long address = OffsetAddress;

                    OffsetEndAddress = address + iSize - 1;

                }

                else

                {

                    OffsetEndAddress = OffsetAddress;

                }

                System.Diagnostics.Debug.Assert( iOffsetEndAddress >= OffsetAddress );

			}

		}

        public AddressRange AddressRange

        {

            get { return new AddressRange( Address, EndAddress ); }

        }

		public string Symbol

		{

			get { return iSymbol; }

			set

			{

				iSymbol = value;

                if ( StartsWithAny( KVTableOrTypeInfoPrefixes, value ) )

                {

                    iFlags |= TFlags.EFlagsVTable;

                }

			}

		}

		public string SymbolNameWithoutVTablePrefix

		{

			get

            {

                StringBuilder ret = new StringBuilder( Symbol );

                //

                ret = ret.Replace( "vtable for ", string.Empty );

                ret = ret.Replace( "typeinfo for ", string.Empty );

                ret = ret.Replace( "typeinfo name for ", string.Empty );

                //

                return ret.ToString();

            }

		}

		public string Object

		{

			get { return iObject; }

			set { iObject = value; }

		}

		public string ObjectWithoutSection

		{

			get

			{

				string ret = string.Empty;

                //

                if  ( Object != null )

                {

                    ret = Object;

                    //

                    int bracketPos = ret.IndexOf( "(" );

                    if	( bracketPos > 0 )

                    {

                        ret = ret.Substring( 0, bracketPos ).Trim();

                    }

                }

                // Casing looks odd and it can also confuse

                // hash table look ups in dependent code.

                //ret = SymbianUtils.Strings.StringCaser.PrettyCase( ret );

				return ret;

			}

		}

        public GenericSymbolCollection Collection

        {

            get { return iCollection; }

        }

        public bool IsUnknownSymbol

        {

            get

            {

                bool ret = Symbol.StartsWith( KNonMatchingSymbolName ) &&

                           ( OffsetAddress == GenericSymbol.KNullEntryAddress );

                return ret;

            }

        }

        public bool IsVTable

        {

            get

            {

                bool ret = ( iFlags & TFlags.EFlagsVTable ) == TFlags.EFlagsVTable;

                return ret;

            }

        }

        #endregion

        #region Internal enumerations

        [Flags]

        private enum TFlags : byte

        {

            EFlagsNone = 0,

            EFlagsVTable = 1,

            EFlagsIsThumb = 2,

        };

        #endregion

        #region Internal properties

        internal long OffsetAddress

        {

            get { return iOffsetAddress; }

            set

            {

                long remainder = value & 0x1;

                if ( remainder != 0 )

                {

                    iFlags |= TFlags.EFlagsIsThumb;

                }

                else

                {

                    iFlags &= ~TFlags.EFlagsIsThumb;

                }

                iOffsetAddress = value & 0xFFFFFFFE;

                // If we've not yet decided upon the type of memory model,

                // now is the time to work it out.

                if  ( iOffsetAddress > 0 && iStaticMemoryModelType == MemoryModel.TMemoryModelType.EMemoryModelUnknown )

                {

                    long address = Address;

                    iStaticMemoryModelType = MemoryModel.TypeByAddress( address );

                }

            }

        }

        private long OffsetEndAddress

        {

            set { iOffsetEndAddress = value; }

        }

        #endregion

		#region Internal constants

		protected const int KBaseHex = 16;

        private static readonly string[] KVTableOrTypeInfoPrefixes = new string[] { "vtable for ", "typeinfo for ", "typeinfo name for " };

		#endregion

		#region From System.Object

		public override string ToString()

		{

            string ret = string.Format( "{0:x8}    {1:x4}    {2} [{3}]", Address, Size, Symbol, Object );

			return ret;

		}

        public string ToStringForStream()

        {

            StringBuilder ret = new StringBuilder();

            //

            ret.Append( Address.ToString( "x8" ) );

            ret.Append( "    " );

            ret.Append( Size.ToString( "x4" ) );

            ret.Append( "    " );

            ret.Append( Symbol.PadRight( 40, ' ' ) );

            ret.Append( " " );

            ret.Append( Object );

            //

            return ret.ToString();

        }

        public static bool StartsWithAny( string[] aPrefixes, string aText )

        {

            bool ret = false;

            //

            foreach ( string p in aPrefixes )

            {

                if ( aText.StartsWith( p ) )

                {

                    ret = true;

                    break;

                }

            }

            //

            return ret;

        }

	    #endregion

		#region Data members

		protected long iSize;

		#endregion

		#region Internal data members

		private long iOffsetAddress;

		private long iOffsetEndAddress;

        private string iSymbol = string.Empty;

		private string iObject = string.Empty;

        private TFlags iFlags = TFlags.EFlagsNone;

        private readonly GenericSymbolCollection iCollection;

        private static MemoryModel.TMemoryModelType iStaticMemoryModelType = MemoryModel.TMemoryModelType.EMemoryModelUnknown;

		#endregion

	}

}