/*

* 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 module in project (sbs2)

*

*/

#include "../inc/CATModule2.h"

#include "../inc/CATProject.h"

#include "../inc/CATDatParser.h"

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

#include "../inc/catdbghelper.h"

#include "../inc/cataddr2line.h"

CATModule2::CATModule2(void)

{

	LOG_FUNC_ENTRY("CATModule2::CATModule2");

	m_bAddressToLineInitialized = false;

	m_pAddressToLine = 0;

	m_sErrors = "";

	m_sMakeFile = "";

	m_eBuildSystem = CATProject::SBS_V1;

	m_sCompileInfoText = "";

}

CATModule2::~CATModule2(void)

{

	LOG_FUNC_ENTRY("CATModule2::~CATModule2");

	if ( m_pAddressToLine )

		m_pAddressToLine->Close();

	delete m_pAddressToLine;

}

bool CATModule2::AddressToLine( CATMemoryAddress* pMemoryAddress )

{

	LOG_FUNC_ENTRY("CATModule2::AddressToLine");

	if ( _stricmp( m_sVariantPlatform.c_str(), "winscw" ) == 0 )

	{

		return AddressToLineWinscw( pMemoryAddress );

	}

	else if ( _stricmp( m_sVariantPlatform.c_str(), "armv5" ) == 0 )

	{

		// addr2line exe.

		#ifdef ADDR2LINE

		return AddressToLineAddr2lineExe( pMemoryAddress );

		#endif

		// lst and map files.

		#ifndef ADDR2LINE

		return AddressToLineArmv5( pMemoryAddress );

		#endif

	}

	else if ( _stricmp( m_sVariantPlatform.c_str(), "gcce" ) == 0 )

	{

		return AddressToLineAddr2lineExe( pMemoryAddress );

	}

	return false;

}

bool CATModule2::AddressToLineWinscw( CATMemoryAddress* pMemoryAddress )

{

	LOG_FUNC_ENTRY("CATModule2::AddressToLineWinscw( CATMemoryAddress* pMemoryAddress )");

	if ( m_pAddressToLine == 0 && ! m_bAddressToLineInitialized )

	{

		// Use debug helper to locate codelines on winscw platform.

		m_pAddressToLine = new CATDbgHelper();

		// Create full path to binary which we open using CATDbgHelper.

		string sFullPathToBinary = GetBinaryFile();

		// If opening of binary not succesfull set return value to false.

		if ( ! m_pAddressToLine->Open( sFullPathToBinary, pMemoryAddress->GetModuleStartAddress() ) )

		{

			LOG_STRING("Error, m_pAddressToLine->Open()");

			return false;

		}

		m_bAddressToLineInitialized = true;

	}

	// Check pointer before calling.

	if ( m_pAddressToLine == 0 )

		return false;

	m_pAddressToLine->AddressToLine( pMemoryAddress );

	return true;

}

bool CATModule2::AddressToLineArmv5( CATMemoryAddress* pMemoryAddress )

{

	LOG_FUNC_ENTRY("CATModule2::AddressToLine( CATMemoryAddress* pMemoryAddress )");

	if ( ! m_bAddressToLineInitialized )

		return false;

	// Find from map file

	int iMapIndex = GetSymbolIndexUsingAddress( pMemoryAddress->GetOffSetFromModuleStart() );

	if ( iMapIndex == -1 )

	{

		pMemoryAddress->SetAddressToLineState( CATMemoryAddress::OUT_OF_RANGE );

		return true;

	}

	// Set symbol name

	string sSymbolName = m_vMapFileFuncList.at( iMapIndex ).sFunctionName;

	// Remove (... from symbol name

	string sSymbolNameRefined( sSymbolName );

	size_t iPos = sSymbolNameRefined.find( "(" );

	if ( iPos != string::npos )

		sSymbolNameRefined.resize( iPos );

	// Set symbol name as function name for memory address

	pMemoryAddress->SetFunctionName( sSymbolNameRefined );

	// Set state to symbol

	pMemoryAddress->SetAddressToLineState( CATMemoryAddress::SYMBOL );

	// Offset from function start addr

	int iOffSetFromFuncStart = pMemoryAddress->GetOffSetFromModuleStart()

		- m_vMapFileFuncList.at( iMapIndex ).iAddress;

	// Find from lst list

	int iLstIndex = GetLineInFileIndexUsingSymbolName( sSymbolName );

	if ( iLstIndex == -1 )

		return true;

	// Set pinpointing

	int iFuncLineNumber = m_vLineInFile.at( iLstIndex ).iLine;

	string sFileName = m_vLineInFile.at( iLstIndex ).sFileName;

	string sLstFileName = m_vLineInFile.at( iLstIndex ).sLstName;

	pMemoryAddress->SetFunctionLineNumber( iFuncLineNumber );

	pMemoryAddress->SetFileName( sFileName );

	pMemoryAddress->SetAddressToLineState( CATMemoryAddress::FUNCTION );

	// In urel mode don't get exact code line

	if ( ! IsUDEB() )

		return true;

	// Next calculate the code line inside function

	int iExactLineNumber = FindLeakCodeLine( sLstFileName, iFuncLineNumber, iOffSetFromFuncStart );

	pMemoryAddress->SetExactLineNumber( iExactLineNumber );

	// State is now exact

	pMemoryAddress->SetAddressToLineState( CATMemoryAddress::EXACT );

	return true;

}

bool CATModule2::AddressToLineAddr2lineExe( CATMemoryAddress* pMemoryAddress )

{

	LOG_FUNC_ENTRY("CATModule2::AddressToLineAddr2lineExe( CATMemoryAddress* pMemoryAddress )");

	if ( m_pAddressToLine == 0 && ! m_bAddressToLineInitialized )

	{

		// Use addr2line.exe to locate codelines on armv5 and gcce platform.

		m_pAddressToLine = new CATAddr2line();

		// Create full path to binary .sym file which we open using addr2line.exe.

		string sFullPathToBinary = GetBinaryFile();

		// If opening of binary not succesfull set return value to false.

		if ( ! m_pAddressToLine->Open( sFullPathToBinary, pMemoryAddress->GetModuleStartAddress() ) )

		{

			LOG_STRING("Error, m_pAddressToLine->Open()");

			return false;

		}

		m_bAddressToLineInitialized = true;

	}

	// Check pointer before calling.

	if ( m_pAddressToLine == 0 )

		return false;

	m_pAddressToLine->AddressToLine( pMemoryAddress );

	return true;

}

// Find symbol of given address

int CATModule2::GetSymbolIndexUsingAddress( unsigned long iAddress ) const

{

	LOG_LOW_FUNC_ENTRY("CATModule2::GetSymbolIndexUsingAddress");

	for( size_t i = 0; i < m_vMapFileFuncList.size(); i++ )

	{

		unsigned long iStart = m_vMapFileFuncList.at( i ).iAddress;

		unsigned long iEnd = ( m_vMapFileFuncList.at( i ).iAddress

			+ m_vMapFileFuncList.at( i ).iFuncLength );

		if ( iAddress >= iStart && iAddress < iEnd )

			return (int) i;

	}

	return -1;

}

// Find index of function line in file vector of given symbolname

int CATModule2::GetLineInFileIndexUsingSymbolName( const string& sSymbolName ) const

{

	LOG_LOW_FUNC_ENTRY("CATModule2::GetLineInFileIndexUsingSymbolName");

	for( size_t i = 0; i < m_vLineInFile.size(); i++ )

	{

		string sLineInFileName = m_vLineInFile.at( i ).sFunction;

		if( sLineInFileName.find( sSymbolName ) != string::npos )

		{

			return (int) i;

		}

	}

	return -1;

}

// Check does modules symbol file(s) exist.

bool CATModule2::SymbolFileExist( void )

{

	LOG_FUNC_ENTRY("CATModule2::SymbolFileExist");

	string sFullPathToSym = GetSymbolFile();

	if ( !FileExists( sFullPathToSym.c_str() ) )

	{

		// Add missing symbol file to error string.

		m_sErrors.append( "Missing symbol file: " );

		m_sErrors.append( sFullPathToSym );

		m_sErrors.append( "\n" );

		return false;

	}

	return true;

}

// Check does modules map file(s) exists.

bool CATModule2::MapFileExist( void )

{

	LOG_FUNC_ENTRY("CATModule2::MapFileExist");

	string sFullPathToMap = GetMapFile();

	if ( !FileExists( sFullPathToMap.c_str() ) )

	{

		// Add missing symbol file to error string.

		m_sErrors.append( "Missing map file: " );

		m_sErrors.append( sFullPathToMap );

		m_sErrors.append( "\n" );

		return false;

	}

	return true;

}

//Check does modules binary file(s) exist.

bool CATModule2::BinaryFileExist( void )

{

	LOG_FUNC_ENTRY("CATModule2::BinaryFileExist");

	string sFullPathToBinary = GetBinaryFile();

	if ( ! FileExists( sFullPathToBinary.c_str() ) )

	{

		// Add missing binary to error string.

		m_sErrors.append( "Missing binary file: " );

		m_sErrors.append( sFullPathToBinary );

		m_sErrors.append( "\n" );

		return false;

	}

	return true;

}

void CATModule2::AddSource(const string &sSourceFile, const string& sLstFile)

{

	LOG_LOW_FUNC_ENTRY("CATModule2::AddSource");

	// Parse sources which are separated by spaces

	if( sSourceFile.length() < 1  || sLstFile.length() < 1 )

		return;

	// Skip if its temporary cpp.

	if ( sSourceFile.find( AT_TEMP_CPP_LOWER_START) != string::npos )

		return;

	// Source structure

	SOURCE sNew;

	sNew.sCpp =  sSourceFile;

	sNew.sLst = sLstFile;

	// Verify paths.

	ConvertUnixPathToWin( sNew.sCpp );

	ConvertUnixPathToWin( sNew.sLst );

	// Lower case them.

	ChangeToLower( sNew.sCpp );

	ChangeToLower( sNew.sLst );

	// Add it

	m_vSources.push_back( sNew );

}

void CATModule2::AddSources(string& sSource)

{

	LOG_LOW_FUNC_ENTRY("CATModule2::AddSources");

	// Parse sources which are separated by spaces

	if( sSource.length() < 1 )

		return;

	// Source structure

	SOURCE sNew;

	size_t iSpot = string::npos;

	iSpot = sSource.find( " " );

	while( iSpot != string::npos )

	{

		// Pickup source

		sNew.sCpp = sSource.substr(0, iSpot);

		// Convert path from Unix to Win

		ConvertUnixPathToWin( sNew.sCpp );

		// Lowercase it

		ChangeToLower( sNew.sCpp );

		// If its temp skip this

		if ( sNew.sCpp.find( AT_TEMP_CPP_LOWER_START ) == string::npos )

		{

			// Get corresponding lst file for source

			sNew.sLst = GetLstNameOfSource( sNew.sCpp );

			m_vSources.push_back( sNew );

			// Remove it from sSource

			sSource.erase(0,iSpot+1);

			// Find new one

		}

		iSpot = sSource.find( " " );

	}

	// Pickup last or only one source

	sNew.sCpp = sSource;

	// Convert path from unix to win

	ConvertUnixPathToWin( sNew.sCpp );

	// Lowercase it

	ChangeToLower( sNew.sCpp );

	// Lst name

	sNew.sLst = GetLstNameOfSource( sNew.sCpp );

	if ( sNew.sCpp.find( AT_TEMP_CPP_LOWER_START ) == string::npos )

	{

		// Get corresponding lst file for source

		sNew.sLst = GetLstNameOfSource( sNew.sCpp );

		m_vSources.push_back( sNew );

	}

}

bool CATModule2::CreateTempCpp(const string& sS60FileName

									, int eLoggingMode

									, int eBuildType

									, int iAllocCallStackSize

									, int iFreeCallStackSize )

{

	LOG_FUNC_ENTRY("CATModule2::CreateTemporaryCpp");

	// Make s60 filename target.type.dat if its empty and logging mode is file

	{

	}

	return CreateTemporaryCpp( GetUniqueId(), m_sTempPath,

}

bool CATModule2::ModifyMmp()

{

	LOG_FUNC_ENTRY("CATModule2::ModifyMmp");

	// Create backup

	if ( ! m_Mmp.BackupMmpFile() )

		return false;

	// Hook

	return m_Mmp.EditMmpFile( m_sTargetType, GetUniqueId() );

}

bool CATModule2::RestoreMmp()

{

	LOG_FUNC_ENTRY("CATModule2::RestoreMmp");

	// Restore mmp from backup

	return m_Mmp.RestoreMmpFile();

}

bool CATModule2::VerifyAndRecoverMmp()

{

	LOG_FUNC_ENTRY("CATModule2::VerifyAndRecoverMmp");

	// Verify mmp

	return m_Mmp.VerifyAndRecover();

}

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

// Releasables Handling methos

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

bool CATModule2::CopyReleasables()

{

	LOG_FUNC_ENTRY("CATModule2::CopyReleasables");

	bool bRet = true;

	if ( ! CopyLstFilesToTemp() )

		bRet = false;

	if ( ! CopyMapFileToTemp() )

		bRet = false;

	return bRet;

}

bool CATModule2::CopyLstFilesToDir( const string& sDir )

{

	LOG_FUNC_ENTRY("CATModule2::CopyLstFilesToDir");

	bool bRet = true;

	// Copy lst files to given directory.

	vector<SOURCE>::const_iterator source;

	for( source = m_vSources.begin(); source != m_vSources.end() ; source++ )

	{

		if ( ! FileCopyToPath( source->sLst, sDir ) )

		{

			if ( !FileExists( source->sLst.c_str() ) )

			{

				m_sErrors.append( "Missing listing file: " );

				m_sErrors.append( source->sLst );

				m_sErrors.append( "\n" );

			}

			if ( !DirectoryExists( sDir.c_str() ) )

			{

				m_sErrors.append( "Missing folder: " );

				m_sErrors.append( sDir );

				m_sErrors.append( "\n" );

			}

			bRet = false;

		}

	}

	// Return.

	return bRet;

}

bool CATModule2::CopyLstFilesToTemp()

{

	LOG_FUNC_ENTRY("CATModule2::CopyLstFilesToTemp");

	// Return boolean

	bool bRet = true;

	// Move all lst files except tmp cpp

	vector<SOURCE>::iterator it = m_vSources.begin();

	while ( it != m_vSources.end() )

	{

		if ( !FileCopyToPath( it->sLst, m_sTempPath ) )

		{

			if ( !FileExists( it->sLst.c_str() ) )

			{

				m_sErrors.append( "Missing listing file: " );

				m_sErrors.append( it->sLst );

				m_sErrors.append( "\n" );

			}

			if ( !DirectoryExists( m_sTempPath.c_str() ) )

			{

				m_sErrors.append( "Missing folder: " );

				m_sErrors.append( m_sTempPath );

				m_sErrors.append( "\n" );

			}

			bRet = false;

		}

		it++;

	}

	return bRet;

}

bool CATModule2::DeleteLstFilesFromSrc( void )

{

	LOG_FUNC_ENTRY("CATModule2::DeleteLstFilesFromSrc");

	vector<SOURCE>::iterator it = m_vSources.begin();

	bool bRet = true;

	// Delete lst files

	while ( it != m_vSources.end() )

	{

		if ( ! FileDelete( it->sLst, true ) )

			bRet = false;

		it++;

	}

	return bRet;

}

bool CATModule2::CopyMapFileToTemp()

{

	LOG_FUNC_ENTRY("CATModule2::CopyMapFileToTemp");

	// Return boolean

	bool bRet = true;

	// Map File to copy

	string sMapFile = GetMapFile();

	if ( !FileCopyToPath( sMapFile, m_sTempPath ) )

	{

		bRet = false;

		if ( !FileExists( sMapFile.c_str() ) )

		{

			// Add missing map file to error string.

			m_sErrors.append( "Missing map file: " );

			m_sErrors.append( sMapFile );

			m_sErrors.append( "\n" );

		}

		if ( !DirectoryExists( m_sTempPath.c_str() ) )

		{

			// Add missing temporary folder

			m_sErrors.append( "Missing folder: " );

			m_sErrors.append( m_sTempPath );

			m_sErrors.append( "\n" );

		}

	}

	return bRet;

}

bool CATModule2::CleanTemporaryDir()

{

	LOG_FUNC_ENTRY("CATModule2::CleanTemporaryDir");

	bool bRet = true;

	// Verify mmp

	if ( ! m_Mmp.VerifyAndRecover() )

		bRet = false;

	// Clean temporary dir

	vector<string> vFileList = DirList( m_sTempPath, false , true );

	vector<string>::iterator it = vFileList.begin();

	// Size of constant table

	int iCount = sizeof( TEMP_EXTENSION_NO_DELETE ) / sizeof( string );

	while ( it != vFileList.end() )

	{

		// Get extension and compare it to list

		bool bDelete = true;

		string sExtension = GetExtension( *it );

		ChangeToLower( sExtension );

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

		{

			if( sExtension.compare( TEMP_EXTENSION_NO_DELETE[i] ) == 0 )

			{

				bDelete = false;

				break;

			}

		}

		if ( bDelete )

		{

			// Delete file

			if ( ! FileDelete( *it, true ) )

				bRet = false;