/*

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

using SymbianUtils.PluginManager;

using SymbianStructuresLib.Arm;

using SymbianStructuresLib.Arm.Disassembler;

using SymbianStructuresLib.Arm.Instructions;

using SymbianInstructionLib.Arm.Instructions.Arm;

using SymbianInstructionLib.Arm.Instructions.Thumb;

using SymbianInstructionLib.Arm.Instructions.Common;

using System.Reflection;

namespace SymbianInstructionLib.Arm.Library

{

    public class ArmLibrary

    {

        #region Constructors

        public ArmLibrary()

        {

        }

        static ArmLibrary()

        {

            // Load all the ARM instructions

            Comparison<ArmInstruction> armInstructionComparer = delegate( ArmInstruction aLeft, ArmInstruction aRight )

            {

                // We sort in reverse order, hence right compared to left

                return aRight.SortOrder.CompareTo( aLeft.SortOrder );

            };

            iArmInstructions = new PluginManager<ArmInstruction>();

            iArmInstructions.LoadFromCallingAssembly();

            iArmInstructions.Sort( armInstructionComparer );

            // Load all the THUMB instructions

            Comparison<ThumbInstruction> thumbInstructionComparer = delegate( ThumbInstruction aLeft, ThumbInstruction aRight )

            {

                // We sort in reverse order, hence right compared to left

                return aRight.SortOrder.CompareTo( aLeft.SortOrder );

            };

            iThumbInstructions = new PluginManager<ThumbInstruction>();

            iThumbInstructions.LoadFromCallingAssembly();

            iThumbInstructions.Sort( thumbInstructionComparer );

            // Load disassembler if present

            iDisassembler = new PluginManager<IArmDisassembler>();

            iDisassembler.Load( null );

        }

        #endregion

        #region API

        public IArmInstruction[] ConvertToInstructions( TArmInstructionSet aInstructionSet, uint[] aRawInstructions, uint aStartingAddress )

        {

            IArmInstruction[] ret = null;

            //

            switch ( aInstructionSet )

            {

            case TArmInstructionSet.EARM:

                ret = ConvertToArm( aRawInstructions, aStartingAddress );

                break;

            case TArmInstructionSet.ETHUMB:

                ret = ConvertToThumb( aRawInstructions, aStartingAddress );

                break;

            default:

                throw new NotSupportedException();

            }

            //

            return ret;

        }

        #endregion

        #region Properties

        #endregion

        #region Internal methods

        private void Disassemble( ArmBaseInstruction aInstruction )

        {

            if ( iDisassembler.Count > 0 )

            {

                IArmDisassembler disassembler = iDisassembler[ 0 ];

                string disassembly = disassembler.Disassemble( aInstruction );

                aInstruction.AIDisassembly = disassembly;

            }

        }

        private IArmInstruction[] ConvertToArm( uint[] aRawInstructions, uint aStartingAddress )

        {

            // TODO: optimise this

            List<IArmInstruction> ret = new List<IArmInstruction>();

            //

            uint address = aStartingAddress;

            for ( int i = 0; i < aRawInstructions.Length; i++, address += 4 )

            {

                uint raw = aRawInstructions[ i ];

                foreach ( ArmInstruction inst in iArmInstructions )

                {

                    if ( inst.Matches( raw ) )

                    {

                        Type type = inst.GetType();

                        ConstructorInfo ctor = type.GetConstructor( new Type[] { } );

                        ArmInstruction copy = (ArmInstruction) ctor.Invoke( new object[] { } );

                        copy.AIAddress = address;

                        copy.AIRawValue = raw;

                        ret.Add( copy );

                        Disassemble( copy );

                        break;

                    }

                }

            }

            //

            return ret.ToArray();

        }

        private IArmInstruction[] ConvertToThumb( uint[] aRawInstructions, uint aStartingAddress )

        {

            // TODO: optimise this

            List<IArmInstruction> ret = new List<IArmInstruction>();

            //

            uint address = aStartingAddress;

            for ( int i = 0; i < aRawInstructions.Length; i++, address += 2 )

            {

                uint raw = aRawInstructions[ i ];

                foreach ( ThumbInstruction inst in iThumbInstructions )

                {

                    if ( inst.Matches( raw ) )

                    {

                        Type type = inst.GetType();

                        ConstructorInfo ctor = type.GetConstructor( new Type[] { } );

                        ThumbInstruction copy = (ThumbInstruction) ctor.Invoke( new object[] { } );

                        copy.AIAddress = address;

                        copy.AIRawValue = raw;

                        ret.Add( copy );

                        Disassemble( copy );

                        break;

                    }

                }

            }

            //

            return ret.ToArray();

        }

        #endregion

        #region Data members

        private static readonly PluginManager<ArmInstruction> iArmInstructions;

        private static readonly PluginManager<ThumbInstruction> iThumbInstructions;

        private static readonly PluginManager<IArmDisassembler> iDisassembler;

        #endregion

    }

}