/*

* 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:  Class representing a memory address and its details.

*

*/

#include "../inc/CATMemoryAddress.h"

#include "../inc/CATBase.h"

// -----------------------------------------------------------------------------

// CATMemoryAddress::CATMemoryAddress

// Constructor

// -----------------------------------------------------------------------------

CATMemoryAddress::CATMemoryAddress(string& sAddress, unsigned long iOffSet)

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::CATMemoryAddress");

	m_sAddress = sAddress;

	m_sFileName = "";

	m_sFunctionName = "";

	m_sModuleName = "";

	m_iAddress = CATBase::_httoi( sAddress.c_str() );

	m_iDllLoadinfoIndex = -1;

	m_iModuleStartAddress = 0;

	m_iOffSetFromModuleStart = 0;

	m_iExactLineNumber = -1;

	m_iFunctionLineNumber = -1;

	m_ePinPointState = OUT_OF_PROCESS;

	m_iOffSet = iOffSet;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::~CATMemoryAddress

// Destructor.

// -----------------------------------------------------------------------------

CATMemoryAddress::~CATMemoryAddress()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::~CATMemoryAddress");

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::FindSetModuleName

// Find which binary this address belongs to.

// Sets also the offsetfrommodulestart.

// -----------------------------------------------------------------------------

bool CATMemoryAddress::FindSetModuleName(vector<DLL_LOAD_INFO>* vDlls)

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::FindSetModuleName");

	vector<DLL_LOAD_INFO>::iterator it;

	for (  it = vDlls->begin() ;

		it != vDlls->end(); it++ )

	{

		// Is modules load time defined?

		if ( (*it).iLoadTime > 0 )

		{

			// Check that load time is earlier or same as allocation

			if ( m_iTime >= (*it).iLoadTime

				&& m_iAddress >= (*it).iStartAddress 

				&& m_iAddress < (*it).iEndAddress )

			{

				// Module is loaded until process end.

				if ( (*it).iUnloadTime == 0 )

					break;

				// Check is allocation done before module was unloaded.

				else if ( (*it).iUnloadTime >= m_iTime )

					break;

			}

		}

		// Module has no time defined use only code segments.

		else

		{

			if ( m_iAddress >= (*it).iStartAddress 

				&& m_iAddress < (*it).iEndAddress )

				break;

		}

	}

	// Did we not find module where address is?

	if ( it == vDlls->end() )

		return false;

	m_ePinPointState = OUT_OF_RANGE;

	m_sModuleName = (*it).sModuleName;

	m_iModuleStartAddress = (*it).iStartAddress;

	m_iOffSetFromModuleStart = m_iAddress - m_iModuleStartAddress;

	m_iOffSetFromModuleStart += m_iOffSet;

	m_iDllLoadinfoIndex = distance( vDlls->begin(), it ) ;

	return true;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::SetModuleStartAddress

// Set start address of the binary in which address resides.

// Note, this also sets the offset from start value.

// -----------------------------------------------------------------------------

void CATMemoryAddress::SetModuleStartAddress(unsigned long iAddress)

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetModuleStartAddress");

	m_iModuleStartAddress = iAddress;

	m_iOffSetFromModuleStart = m_iAddress - m_iModuleStartAddress;

	m_iOffSetFromModuleStart += m_iOffSet;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::GetOffSetFromModuleStart

// Note return value includes the set offset.

// So this value is not binary start - address.

// Instead it is.

// memory address - binary start address + offset

// -----------------------------------------------------------------------------

unsigned long CATMemoryAddress::GetOffSetFromModuleStart()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetOffSetFromModuleStart");

	return m_iOffSetFromModuleStart;

}

int CATMemoryAddress::GetDllLoadInfoIndex()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetDllLoadInfo");

	return m_iDllLoadinfoIndex;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::SetTime

// -----------------------------------------------------------------------------

void CATMemoryAddress::SetTime( unsigned long long& ullTime )

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetTime");

	m_iTime = ullTime;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::GetTIme

// -----------------------------------------------------------------------------

unsigned long long CATMemoryAddress::GetTime()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetTime");

	return m_iTime;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::SetAddress

// -----------------------------------------------------------------------------

void CATMemoryAddress::SetAddress(string& sAddress)

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetAddress");

	m_sAddress = sAddress;

	m_iAddress = CATBase::_httoi( sAddress.c_str() );

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::GetAddressString

// -----------------------------------------------------------------------------

string CATMemoryAddress::GetAddressString()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetAddressString");

	return m_sAddress;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::SetAddress

// -----------------------------------------------------------------------------

void CATMemoryAddress::SetAddress(unsigned long iAddress)

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetAddress");

	m_iAddress = iAddress;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::GetAddress

// -----------------------------------------------------------------------------

unsigned long CATMemoryAddress::GetAddress()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetAddress");

	return m_iAddress;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::SetModuleName

// -----------------------------------------------------------------------------

void CATMemoryAddress::SetModuleName(string& sModuleName)

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetModuleName");

	m_sModuleName = sModuleName;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::GetModuleName

// -----------------------------------------------------------------------------

string CATMemoryAddress::GetModuleName()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetModuleName");

	return m_sModuleName;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::SetAddressToLineState

// -----------------------------------------------------------------------------

void CATMemoryAddress::SetAddressToLineState( ADDRESS_TO_LINE_STATE eState )

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetAddressToLineState");

	m_ePinPointState = eState;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::GetAddressToLineState

// -----------------------------------------------------------------------------

int CATMemoryAddress::GetAddressToLineState()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetAddressToLineState");

	return m_ePinPointState;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::SetFileName

// -----------------------------------------------------------------------------

void CATMemoryAddress::SetFileName(string& sFileName)

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetFileName");

	m_sFileName = sFileName;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::GetFileName

// -----------------------------------------------------------------------------

string CATMemoryAddress::GetFileName()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetFileName");

	return m_sFileName;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::SetFunctionName

// -----------------------------------------------------------------------------

void CATMemoryAddress::SetFunctionName(string& sFunctionName)

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetFunctionName");

	m_sFunctionName = sFunctionName;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::GetFunctionName

// -----------------------------------------------------------------------------

string CATMemoryAddress::GetFunctionName()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetFunctionName");

	return m_sFunctionName;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::SetFunctionLineNumber

// -----------------------------------------------------------------------------

void CATMemoryAddress::SetFunctionLineNumber(int iFunctionLineNumber)

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetFunctionLineNumber");

	m_iFunctionLineNumber = iFunctionLineNumber;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::GetFunctionLineNumber

// -----------------------------------------------------------------------------

int CATMemoryAddress::GetFunctionLineNumber()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetFunctionLineNumber");

	return m_iFunctionLineNumber;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::SetExactLineNumber

// -----------------------------------------------------------------------------

void CATMemoryAddress::SetExactLineNumber(int iExactLineNumber)

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetExactLineNumber");

	m_iExactLineNumber = iExactLineNumber;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::GetExactLineNumber

// -----------------------------------------------------------------------------

int CATMemoryAddress::GetExactLineNumber()

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetExactLineNumber");

	return m_iExactLineNumber;

}

// -----------------------------------------------------------------------------

// CATMemoryAddress::GetModuleStartAddress

// -----------------------------------------------------------------------------

unsigned long CATMemoryAddress::GetModuleStartAddress() const

{

	LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetModuleStartAddress");

	return m_iModuleStartAddress;

}

//EOF