/*

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

*

*/

#include <memspy/engine/memspyenginehelpercodesegment.h>

// System includes

#include <e32capability.h>

#include <f32file.h>

#include <babitflags.h>

// Driver includes

#include <memspy/driver/memspydriverclient.h>

// User includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineutils.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

// Constants

const TInt KMemSpyEngineMaxCodeSegmentCount = 512;

// Literal constants

_LIT( KMemSpyEngineCodeSegListOutputComma, ", " );

CMemSpyEngineHelperCodeSegment::CMemSpyEngineHelperCodeSegment( CMemSpyEngine& aEngine )

:   iEngine( aEngine )

    {

    }

CMemSpyEngineHelperCodeSegment::~CMemSpyEngineHelperCodeSegment()

    {

    }

void CMemSpyEngineHelperCodeSegment::ConstructL()

    {

    }

CMemSpyEngineHelperCodeSegment* CMemSpyEngineHelperCodeSegment::NewL( CMemSpyEngine& aEngine )

    {

    CMemSpyEngineHelperCodeSegment* self = new(ELeave) CMemSpyEngineHelperCodeSegment( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C void CMemSpyEngineHelperCodeSegment::OutputCodeSegmentsL( TUint aPid, TDes& aLine, const TDesC& aPrefix, TChar aSectionUnderlineCharacter, TBool aLowerCaseSectionHeading)

    {

	_LIT(KHeaderLC, "Code Segments");

	_LIT(KHeaderUC, "CODE SEGMENTS");

	_LIT(KFmtOverflow, "Only first %d code segments displayed");

	_LIT(KFmtMod, "%S%08X-%08X %S");

	const TInt KMaxCount = 256;

	TAny* handles[KMaxCount];

	TInt c = KMaxCount;

	TInt r = iEngine.Driver().GetCodeSegs(aPid, handles, c);

	if  ( r == KErrNone )

    	{

        if  ( c > 0 )

            {

            if  ( aLowerCaseSectionHeading )

                {

                iEngine.Sink().OutputSectionHeadingL( KHeaderLC, aSectionUnderlineCharacter );

                }

            else

                {

            	iEngine.Sink().OutputSectionHeadingL( KHeaderUC, aSectionUnderlineCharacter );

                }

        	if (c > KMaxCount)

        		{

        		c = KMaxCount;

        		aLine.Format(KFmtOverflow, c);

        		iEngine.Sink().OutputLineL( aLine );

        		}

        	TBuf<KMaxFileName> path;

        	TMemSpyDriverCodeSegInfo info;

        	for (TInt i=0; i<c; i++)

        		{

        		r = iEngine.Driver().GetCodeSegInfo(handles[i], aPid, info);

                //

        		if  ( r == KErrNone )

        			{

        			path.Copy( info.iCreateInfo.iFileName );

        			aLine.Format(KFmtMod, &aPrefix, info.iMemoryInfo.iCodeBase,info.iMemoryInfo.iCodeBase + info.iMemoryInfo.iCodeSize, &path);

        			iEngine.Sink().OutputLineL( aLine );

        			}

        		}

            }

        }

   }

EXPORT_C CMemSpyEngineCodeSegList* CMemSpyEngineHelperCodeSegment::CodeSegmentListL()

    {

    RArray<TAny*> handles( 16 );

    CleanupClosePushL( handles );

    // Get everything

    GetCodeSegmentHandlesL( handles, NULL, EFalse );

    CMemSpyEngineCodeSegList* list = ListFromHandlesLC( handles );

    //

    CleanupStack::Pop( list );

    CleanupStack::PopAndDestroy( &handles );

    //

    return list;

    }

CMemSpyEngineCodeSegList* CMemSpyEngineHelperCodeSegment::CodeSegmentListRamLoadedL()

    {

    RArray<TAny*> handles( 16 );

    CleanupClosePushL( handles );

    // Get just RAM-loaded

    GetCodeSegmentHandlesL( handles, NULL, ETrue );

    CMemSpyEngineCodeSegList* list = ListFromHandlesLC( handles );

    //

    CleanupStack::Pop( list );

    CleanupStack::PopAndDestroy( &handles );

    //

    return list;

    }

EXPORT_C CMemSpyEngineCodeSegList* CMemSpyEngineHelperCodeSegment::CodeSegmentListL( TProcessId aProcess )

    {

    TUint processId = aProcess;

    //

    RArray<TAny*> handles( 16 );

    CleanupClosePushL( handles );

    // Get process-specific list

    GetCodeSegmentHandlesL( handles, &processId, EFalse );

    CMemSpyEngineCodeSegList* list = ListFromHandlesLC( handles );

    //

    CleanupStack::Pop( list );

    CleanupStack::PopAndDestroy( &handles );

    //

    return list;

    }

void CMemSpyEngineHelperCodeSegment::GetCodeSegmentHandlesL( RArray<TAny*>& aHandles, TUint* aProcessId, TBool aRamOnly ) const

    {

	TAny* handles[ KMemSpyEngineMaxCodeSegmentCount ];

	TInt count = KMemSpyEngineMaxCodeSegmentCount;

	TInt r = KErrNone;

	if  ( aProcessId == NULL )

    	{

	    r = iEngine.Driver().GetCodeSegs( handles, count, aRamOnly );

	    }

    else

	    {

	    r = iEngine.Driver().GetCodeSegs( *aProcessId, handles, count );

	    }

	if  ( r == KErrNone )

    	{

        TInt index;

        TLinearOrder< TAny* > comparer( SortByAddress );

        // Remove duplicates - since we reqested code segments for all processes, there

        // might be some dupes.

        count = Min( count, KMemSpyEngineMaxCodeSegmentCount );

        for( index = 0; index < count; index++ )

            {

            TAny* handle = handles[ index ];

            const TInt error = aHandles.InsertInOrder( handle, comparer );

            //

            if  ( ! (error == KErrNone || error == KErrAlreadyExists ) )

                {

                User::Leave( error );

                }

            }

        }

    }

CMemSpyEngineCodeSegList* CMemSpyEngineHelperCodeSegment::ListFromHandlesLC( RArray<TAny*>& aHandles ) const

    {

    CMemSpyEngineCodeSegList* list = CMemSpyEngineCodeSegList::NewLC( iEngine );

    //

    TMemSpyDriverCodeSegInfo info;

    const TInt count = aHandles.Count();

    //

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

        {

        TAny* handle = aHandles[ i ];

        const TInt err = iEngine.Driver().GetCodeSegInfo( handle, 0, info );

        //

        if  ( err == KErrNone )

        	{

            // Create item

            CMemSpyEngineCodeSegEntry* entry = CMemSpyEngineCodeSegEntry::NewLC( handle, info.iSize, info.iCreateInfo, info.iMemoryInfo );

            list->AddItemL( entry );

            CleanupStack::Pop( entry );

        	}

        }

    //

    return list;

    }

TInt CMemSpyEngineHelperCodeSegment::SortByAddress( TAny* const& aLeft, TAny* const& aRight )

    {

    TInt ret = 1;

    //

    if  ( aLeft < aRight )

        {

        ret = -1;

        }

    else if ( aLeft == aRight )

        {

        ret = 0;

        }

    //

    return ret;

    }

CMemSpyEngineCodeSegList::CMemSpyEngineCodeSegList( CMemSpyEngine& aEngine )

:   CMemSpyEngineTwiddlableItemArray<CMemSpyEngineCodeSegEntry>( aEngine )

    {

    }

void CMemSpyEngineCodeSegList::ConstructL()

    {

    }

CMemSpyEngineCodeSegList* CMemSpyEngineCodeSegList::NewLC( CMemSpyEngine& aEngine )

    {

    CMemSpyEngineCodeSegList* self = new(ELeave) CMemSpyEngineCodeSegList( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

EXPORT_C TInt CMemSpyEngineCodeSegList::IndexByHandle( TAny* aHandle ) const

    {

    TInt index = KErrNotFound;

    //

    const TInt count = Count();

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

        {

        const CMemSpyEngineCodeSegEntry& entry = At( i );

        if  ( entry.Handle() == aHandle )

            {

            index = i;

            break;

            }

        }

    //

    return index;

    }

EXPORT_C void CMemSpyEngineCodeSegList::SortByFileNameL()

    {

    TLinearOrder< CMemSpyEngineCodeSegEntry > comparer( CompareByFileName );

    Sort( comparer );

    }

EXPORT_C void CMemSpyEngineCodeSegList::SortByCodeSizeL()

    {

    TLinearOrder< CMemSpyEngineCodeSegEntry > comparer( CompareByCodeSize );

    Sort( comparer );

    }

EXPORT_C void CMemSpyEngineCodeSegList::SortByDataSizeL()

    {

    TLinearOrder< CMemSpyEngineCodeSegEntry > comparer( CompareByDataSize );

    Sort( comparer );

    }

EXPORT_C void CMemSpyEngineCodeSegList::SortByUidsL()

    {

    TLinearOrder< CMemSpyEngineCodeSegEntry > comparer( CompareByUid );

    Sort( comparer );

    }

EXPORT_C void CMemSpyEngineCodeSegList::ShowOnlyEntriesWithGlobalDataL()

    {

    TMemSpyEngineVisibiltyFunction< CMemSpyEngineCodeSegEntry > function( VisibilityFunctionGlobalData, NULL );

    ShowL( function );

    SortByDataSizeL();

    }

EXPORT_C void CMemSpyEngineCodeSegList::OutputDataColumnsL( CMemSpyEngine& aEngine )

    {

    HBufC* columns = HBufC::NewLC( 1500 );

    TPtr pColumns( columns->Des() );

    //

    _LIT(KCol1, "Name");

    pColumns.Append( KCol1 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol2, "Uid %d");

    pColumns.AppendFormat( KCol2, 1 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    pColumns.AppendFormat( KCol2, 2 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    pColumns.AppendFormat( KCol2, 3 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol3, "Module Version");

    pColumns.Append( KCol3 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol4, "SID");

    pColumns.Append( KCol4 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol5, "VID");

    pColumns.Append( KCol5 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol6, "Code Size");

    pColumns.Append( KCol6 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol7, "Text Size");

    pColumns.Append( KCol7 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol8, "Data Size");

    pColumns.Append( KCol8 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol9, "BSS Size");

    pColumns.Append( KCol9 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol10, "Total Data Size");

    pColumns.Append( KCol10 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol11, "Entrypoint Veneer");

    pColumns.Append( KCol11 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol12, "File Entrypoint");

    pColumns.Append( KCol12 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol13, "Dependency Count");

    pColumns.Append( KCol13 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol14, "ROM Code Load Address");

    pColumns.Append( KCol14 );

    pColumns.Append( KMemSpyEngineCodeSegListOutputComma );

    //

    _LIT(KCol15, "Data Load Address");

    pColumns.Append( KCol15 );

    //

    _LIT(KCol16, "Capabilities...");

    pColumns.Append( KCol16 );

    //

    aEngine.Sink().OutputLineL( pColumns );

    CleanupStack::PopAndDestroy( columns );

    }

EXPORT_C TInt CMemSpyEngineCodeSegList::MdcaCount() const

    {

    return Count();

    }

EXPORT_C TPtrC CMemSpyEngineCodeSegList::MdcaPoint( TInt aIndex ) const

    {

    const CMemSpyEngineCodeSegEntry& item = At( aIndex );

    return TPtrC( item.Caption() );

    }

TInt CMemSpyEngineCodeSegList::IndexByName( const TDesC& aName ) const

    {

    TInt index = KErrNotFound;

    //

    const TInt count = Count();

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

        {

        const CMemSpyEngineCodeSegEntry& entry = At( i );

        if  ( entry.FileName().FindF( aName ) >= 0 )

            {

            index = i;

            break;

            }

        }

    //

    return index;

    }

TInt CMemSpyEngineCodeSegList::CompareByFileName( const CMemSpyEngineCodeSegEntry& aLeft, const CMemSpyEngineCodeSegEntry& aRight )

    {

    const TInt ret = aLeft.FileName().CompareF( aRight.FileName() );

    return ret;

    }

TInt CMemSpyEngineCodeSegList::CompareByCodeSize( const CMemSpyEngineCodeSegEntry& aLeft, const CMemSpyEngineCodeSegEntry& aRight )

    {

    TInt ret = -1;

    //

    if  ( aLeft.CreateInfo().iCodeSize < aRight.CreateInfo().iCodeSize )

        {

        ret = 1;

        }

    else if ( aLeft.CreateInfo().iCodeSize == aRight.CreateInfo().iCodeSize )

        {

        ret = 0;

        }

    //

    return ret;

    }

TInt CMemSpyEngineCodeSegList::CompareByDataSize( const CMemSpyEngineCodeSegEntry& aLeft, const CMemSpyEngineCodeSegEntry& aRight )

    {

    TInt ret = -1;

    //

    if  ( aLeft.CreateInfo().iTotalDataSize < aRight.CreateInfo().iTotalDataSize )

        {

        ret = 1;

        }

    else if ( aLeft.CreateInfo().iTotalDataSize == aRight.CreateInfo().iTotalDataSize )

        {

        ret = 0;

        }

    //

    return ret;

    }

TInt CMemSpyEngineCodeSegList::CompareByUid( const CMemSpyEngineCodeSegEntry& aLeft, const CMemSpyEngineCodeSegEntry& aRight )

    {

    TInt ret = -1;

    //

    if  ( aLeft.CreateInfo().iUids.MostDerived().iUid < aRight.CreateInfo().iUids.MostDerived().iUid )

        {

        ret = 1;

        }

    else if ( aLeft.CreateInfo().iUids.MostDerived().iUid == aRight.CreateInfo().iUids.MostDerived().iUid )