// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

//

#define _CRTIMP			// we want to use the static runtime library

#include <e32cmn.h>

#include <e32cmn_private.h>

#include <string.h>

#include <emulator.h>

#include <e32ldr.h>

#include <e32ldr_private.h>

#include <e32uid.h>

#pragma data_seg(".data2")

#ifdef __VC32__

#pragma bss_seg(".data2")

#endif

static TBool UnicodeHost;

static Emulator::SInit Data;

#pragma data_seg()

#ifdef __VC32__

#pragma bss_seg()

#endif

/**	

Initializes a module and prepares it to handle requests.

@param aInit	An object of the structure SInit.

@see SInit.

*/

EXPORT_C void Emulator::Init(const Emulator::SInit& aInit)

	{

	UnicodeHost = (GetVersion() & 0x80000000) ? FALSE : TRUE;

	Data = aInit;

	if (Data.iCodePage == 0)

		Data.iCodePage = CP_ACP;

	}

LOCAL_C DWORD UStringLength(LPCSTR lpMultiByteStr)

//

// returns length of unicode string generated - assumes null terminated string

//

	{

	return MultiByteToWideChar(Data.iCodePage,0,lpMultiByteStr,-1,0,0);

	}

LOCAL_C DWORD ConvertToUnicode(LPCSTR aNarrow,LPWSTR aUnicode,DWORD aLength,BOOL aCharsRequired)

//

// Converts narrow string to unicode string

//

	{

	DWORD uniLength=UStringLength(aNarrow);

	if(uniLength>aLength || uniLength==0)

		return aCharsRequired ? uniLength : 0;

	uniLength=MultiByteToWideChar(Data.iCodePage,0,aNarrow,-1,aUnicode,aLength);

	// return number of characters excluding the null terminator

	return uniLength ? uniLength-1 : 0;

	}

LOCAL_C DWORD ConvertToNarrow(LPCWSTR aUnicode,LPSTR aNarrow,DWORD aLength)

//

// Converts unicode string to narrow string

//

	{

	return WideCharToMultiByte(Data.iCodePage,0,aUnicode,-1,aNarrow,aLength,"@",NULL);

	}

template <TUint S>

struct Buf8

	{

public:

	Buf8(LPCWSTR aUnicode);

	inline operator LPCSTR() const

		{return iPtr;}

private:

	const char* iPtr;

	char iBuf[S];

	};

template <TUint S>

Buf8<S>::Buf8(LPCWSTR aUnicode)

	{

	if (aUnicode)

		{

		iPtr = iBuf;

		ConvertToNarrow(aUnicode,iBuf,S);

		}

	else

		{

		iPtr = NULL;

		}

	}

/**	

Acquires the global lock for host interaction.

*/

EXPORT_C void Emulator::Lock()

	{

	Data.iLock();

	}

/**

Releases the global lock for host interaction.

This may overwrite the error code for this thread and that is not the behaviour expected, 

so save and restore it.

*/

EXPORT_C void Emulator::Unlock()

	{

	DWORD error=GetLastError();

	Data.iUnlock();

	SetLastError(error);

	}

/**

Takes the current thread out of the emulator scheduling model.

*/

EXPORT_C void Emulator::Escape()

	{

	Data.iEscape();

	}

/**

Returns the calling thread into the emulator scheduling model.

This may overwrite the error code for this thread and that is not the behaviour expected, 

so save and restore it.

*/

EXPORT_C void Emulator::Reenter()

	{

	DWORD error=GetLastError();

	Data.iReenter();

	SetLastError(error);

	}

/**

Jumps to the NThread Win32 SEH exception handler.

@param aException	Describes an exception.

@param aContext		Describes the context.

@return   A handler to handle the exception occurred

*/

EXPORT_C DWORD Emulator::Win32SEHException(EXCEPTION_RECORD* aException, CONTEXT* aContext)

	{

	return Data.iException(aException, aContext);

	}

/**

This function wraps the Win32 CreateDirectory API (see http://msdn2.microsoft.com/en-us/library/aa363855.aspx).

*/  

EXPORT_C BOOL Emulator::CreateDirectory(LPCWSTR lpPathName,LPSECURITY_ATTRIBUTES lpSecurityAttributes)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::CreateDirectoryW(lpPathName, lpSecurityAttributes);

	return ::CreateDirectoryA(Buf8<MAX_PATH>(lpPathName),lpSecurityAttributes);

	}

#ifdef __VC32__

//disable unreachable code warning in VC++

#pragma warning (disable : 4702)

#endif

/**

Recursively ensures that the full directory exists.

@param aPathName  	Provides the path name.

@return  TRUE, if the function succeeds

		 FALSE, if the function fails

*/

EXPORT_C BOOL Emulator::CreateAllDirectories(LPCSTR aPathName)

	{

	__LOCK_HOST;

	char path[MAX_PATH];

	strcpy(path, aPathName);

	char* p = path;

	for (;;)

		{

		p = strchr(p, '\\');

		char temp=0;

		if (p)

			{

			temp = *++p;

			*p = '\0';

			}

		DWORD att = ::GetFileAttributesA(path);

		if ((att == -1 || !(att&FILE_ATTRIBUTE_DIRECTORY)) && !::CreateDirectoryA(path, NULL))

			return EFalse;

		if (!p)

			return ETrue;

		*p = temp;

		}

	}

#ifdef __VC32__

//enable unreachable code warning in VC++

#pragma warning (default : 4702)

#endif

#ifndef INVALID_FILE_ATTRIBUTES	

#define INVALID_FILE_ATTRIBUTES	 ((DWORD)-1)

#endif

/**

This function wraps the Win32 CreateFile API (see http://msdn2.microsoft.com/en-us/library/aa363858.aspx).

It also modifies file attributes depending on whether the file is hidden or not.

*/

EXPORT_C HANDLE Emulator::CreateFile(LPCWSTR lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode,

						   LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwCreationDistribution,

						   DWORD dwFlagsAndAttributes,HANDLE hTemplateFile)

	{

	__LOCK_HOST;

	HANDLE h;

	BOOL hidden = 0; 

	DWORD att = INVALID_FILE_ATTRIBUTES;

	if(dwCreationDistribution==CREATE_ALWAYS)

		{

		att = ::GetFileAttributes(lpFileName);

		if(att!=INVALID_FILE_ATTRIBUTES && (att&FILE_ATTRIBUTE_HIDDEN))

			{

			hidden = ::SetFileAttributes(lpFileName, (att&~FILE_ATTRIBUTE_HIDDEN));

			}

		}

	if (UnicodeHost)

		h = ::CreateFileW(lpFileName,dwDesiredAccess,dwShareMode,lpSecurityAttributes,dwCreationDistribution,

							dwFlagsAndAttributes,hTemplateFile);

	else

		h = ::CreateFileA(Buf8<MAX_PATH>(lpFileName),dwDesiredAccess,dwShareMode,lpSecurityAttributes,dwCreationDistribution,

						dwFlagsAndAttributes,hTemplateFile);

	if(hidden && h!=INVALID_HANDLE_VALUE)

		{

		::SetFileAttributes(lpFileName, att);

		}

	return h;

	}

/**

This function wraps the Win32 DeleteFile API (see http://msdn2.microsoft.com/en-us/library/aa363915.aspx).

*/

EXPORT_C BOOL Emulator::DeleteFile(LPCWSTR lpFileName)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::DeleteFileW(lpFileName);

	return ::DeleteFileA(Buf8<MAX_PATH>(lpFileName));

	}

LOCAL_C TBool MapFindFileData(LPWIN32_FIND_DATAW lpFindFileData, LPWIN32_FIND_DATAA lpFindNarrow)

	{

	lpFindFileData->dwFileAttributes=lpFindNarrow->dwFileAttributes;

	lpFindFileData->ftCreationTime=lpFindNarrow->ftCreationTime;

	lpFindFileData->ftLastAccessTime=lpFindNarrow->ftLastAccessTime;

	lpFindFileData->ftLastWriteTime=lpFindNarrow->ftLastWriteTime;

	lpFindFileData->nFileSizeHigh=lpFindNarrow->nFileSizeHigh;

	lpFindFileData->nFileSizeLow=lpFindNarrow->nFileSizeLow;

	if(!MultiByteToWideChar(Data.iCodePage,0,lpFindNarrow->cFileName,-1,lpFindFileData->cFileName,MAX_PATH))

		return FALSE;

	if(lpFindNarrow->cAlternateFileName!=NULL)

		{

		// magic number 14 comes from MS documentation

		if(!MultiByteToWideChar(Data.iCodePage,0,lpFindNarrow->cAlternateFileName,-1,lpFindFileData->cAlternateFileName,14))

			return FALSE;

		}

	return TRUE;

	}

/**

This function wraps the Win32 FindFirstFile API (see http://msdn2.microsoft.com/en-us/library/aa364418.aspx).	

*/

EXPORT_C HANDLE Emulator::FindFirstFile(LPCWSTR lpFileName,LPWIN32_FIND_DATAW lpFindFileData)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::FindFirstFileW(lpFileName, lpFindFileData);

	WIN32_FIND_DATAA lpFindNarrow;

	HANDLE h=::FindFirstFileA(Buf8<MAX_PATH>(lpFileName),&lpFindNarrow);

	if(h==INVALID_HANDLE_VALUE)

		return h;

	if (!MapFindFileData(lpFindFileData, &lpFindNarrow))

		{

		FindClose(h);

		return INVALID_HANDLE_VALUE;

		}

	return h;

	}

/**

This function wraps the Win32 FindNextFile API (see http://msdn2.microsoft.com/en-us/library/aa364428.aspx).	

*/

EXPORT_C BOOL Emulator::FindNextFile(HANDLE hFindFile,LPWIN32_FIND_DATAW lpFindFileData)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::FindNextFileW(hFindFile, lpFindFileData);

	WIN32_FIND_DATAA lpFindNarrow;

	if(!::FindNextFileA(hFindFile,&lpFindNarrow))

		return FALSE;

	return MapFindFileData(lpFindFileData, &lpFindNarrow);

	}

/**

This function wraps the Win32 GetDiskFreeSpace API (see http://msdn2.microsoft.com/en-us/library/aa364935.aspx).

*/

EXPORT_C BOOL Emulator::GetDiskFreeSpace(LPCWSTR lpRootPathName,LPDWORD lpSectorsPerCluster,\

							   LPDWORD lpBytesPerSector,LPDWORD lpNumberOfFreeClusters,\

							   LPDWORD lpTotalNumberOfClusters)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetDiskFreeSpaceW(lpRootPathName,lpSectorsPerCluster,lpBytesPerSector,lpNumberOfFreeClusters,lpTotalNumberOfClusters);

	return ::GetDiskFreeSpaceA(Buf8<MAX_PATH>(lpRootPathName),lpSectorsPerCluster,lpBytesPerSector,lpNumberOfFreeClusters,lpTotalNumberOfClusters);

	}

/**

This function wraps the Win32 GetFileAttributes API (see http://msdn2.microsoft.com/en-us/library/aa364944.aspx).

*/

EXPORT_C DWORD Emulator::GetFileAttributes(LPCWSTR lpFileName)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetFileAttributesW(lpFileName);

	return ::GetFileAttributesA(Buf8<MAX_PATH>(lpFileName));

	}

/**

This function wraps the Win32 GetModuleHandle API (see http://msdn2.microsoft.com/en-us/library/ms683199.aspx).

*/

EXPORT_C HMODULE Emulator::GetModuleHandle(LPCWSTR lpModuleName)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetModuleHandleW(lpModuleName);

	return ::GetModuleHandleA(Buf8<MAX_PATH>(lpModuleName));

	}

/**

This function wraps the Win32 GetModuleFileName API (see http://msdn2.microsoft.com/en-us/library/ms683197.aspx).

*/

EXPORT_C DWORD Emulator::GetModuleFileName(HMODULE hModule, LPWSTR lpFilename)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetModuleFileNameW(hModule, lpFilename, MAX_PATH);

	char fn[MAX_PATH];

	DWORD r=::GetModuleFileNameA(hModule, fn, MAX_PATH);

	if (r>MAX_PATH||r==0)

		return 0;

	return ConvertToUnicode(fn, lpFilename, MAX_PATH, TRUE);

	}

/**

This function wraps the Win32 GetTempPath API (see http://msdn2.microsoft.com/en-us/library/Aa364992.aspx).

*/

EXPORT_C DWORD Emulator::GetTempPath(DWORD nBufferLength,LPWSTR lpBuff)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetTempPathW(nBufferLength,lpBuff);

	char path[MAX_PATH];

	DWORD r=::GetTempPathA(MAX_PATH,path);

	if(r>MAX_PATH||r==0)

		return 0;

	return ConvertToUnicode(path,lpBuff,nBufferLength,TRUE);

	}

/**

This function wraps the Win32 GetCurrentDirectory API (see http://msdn2.microsoft.com/en-us/library/aa364934.aspx).

*/

EXPORT_C DWORD Emulator::GetCurrentDirectory(DWORD nBufferLength,LPWSTR lpBuff)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetCurrentDirectoryW(nBufferLength,lpBuff);

	char path[MAX_PATH];

	DWORD r=::GetCurrentDirectoryA(MAX_PATH,path);

	if(r>MAX_PATH||r==0)

		return 0;

	return ConvertToUnicode(path,lpBuff,nBufferLength,TRUE);

	}

/**

This function wraps the Win32 GetVolumeInformation API (see http://msdn2.microsoft.com/en-us/library/aa364993.aspx).

*/

EXPORT_C BOOL Emulator::GetVolumeInformation(LPCWSTR lpRootPathName,LPWSTR lpVolumeNameBuffer,DWORD nVolumeNameSize,

								   LPDWORD lpVolumeSerialNumber,LPDWORD lpMaximumComponentLength,

								   LPDWORD lpFileSystemFlags,LPWSTR,DWORD)

	{

	__LOCK_HOST;

	// lpfileSystemNameBuffer always NULL so no need to convert

	if (UnicodeHost)

		return ::GetVolumeInformationW(lpRootPathName,lpVolumeNameBuffer,nVolumeNameSize,lpVolumeSerialNumber,

										lpMaximumComponentLength,lpFileSystemFlags,NULL,0);

	char volName[MAX_PATH];

	BOOL res=::GetVolumeInformationA(Buf8<MAX_PATH>(lpRootPathName),volName,MAX_PATH,lpVolumeSerialNumber,

									lpMaximumComponentLength,lpFileSystemFlags,NULL,0);

	if(res && lpVolumeNameBuffer)

		ConvertToUnicode(volName,lpVolumeNameBuffer,nVolumeNameSize,FALSE);

	return res;

	}

/**

This function wraps the Win32 LoadLibrary API (see http://msdn2.microsoft.com/en-us/library/ms684175.aspx).

*/

EXPORT_C HMODULE Emulator::LoadLibrary(LPCWSTR lpLibFileName)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::LoadLibraryW(lpLibFileName);

	return ::LoadLibraryA(Buf8<MAX_PATH>(lpLibFileName));

	}

/**

This function wraps the Win32 FreeLibrary API (see http://msdn2.microsoft.com/en-us/library/ms683152.aspx).

*/

EXPORT_C BOOL Emulator::FreeLibrary(HMODULE hLibModule)

	{

	__LOCK_HOST;

	return ::FreeLibrary(hLibModule);

	}

/**

This function wraps the Win32 MoveFile API (see http://msdn2.microsoft.com/en-us/library/aa365239.aspx).

*/

EXPORT_C BOOL Emulator::MoveFile(LPCWSTR lpExistingFileName,LPCWSTR lpNewFileName)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::MoveFileW(lpExistingFileName,lpNewFileName);

	return ::MoveFileA(Buf8<MAX_PATH>(lpExistingFileName),Buf8<MAX_PATH>(lpNewFileName));

	}

/**

This function wraps the Win32 CopyFile API (see http://msdn2.microsoft.com/en-us/library/aa363851.aspx).

*/

EXPORT_C BOOL Emulator::CopyFile(LPCWSTR lpExistingFileName,LPCWSTR lpNewFileName,BOOL aFailIfExists)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::CopyFileW(lpExistingFileName,lpNewFileName,aFailIfExists);

	return ::CopyFileA(Buf8<MAX_PATH>(lpExistingFileName),Buf8<MAX_PATH>(lpNewFileName),aFailIfExists);

	}

/**

This function wraps the Win32 OutputDebugString API (see http://msdn2.microsoft.com/en-us/library/aa363362.aspx).

*/

EXPORT_C VOID Emulator::OutputDebugString(LPCWSTR lpOutputString)

	{

	if (UnicodeHost)

		::OutputDebugStringW(lpOutputString);

	else

		::OutputDebugStringA(Buf8<1024>(lpOutputString));

	}

/**

This function wraps the Win32 RemoveDirectory API (see http://msdn2.microsoft.com/en-us/library/aa365488.aspx).

*/

EXPORT_C BOOL Emulator::RemoveDirectory(LPCWSTR lpPathName)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::RemoveDirectoryW(lpPathName);

	return ::RemoveDirectoryA(Buf8<MAX_PATH>(lpPathName));

	}

/**

This function wraps the Win32 SetFileAttributes API (see http://msdn2.microsoft.com/en-us/library/aa365535.aspx).

*/

EXPORT_C BOOL Emulator::SetFileAttributes(LPCWSTR lpFileName,DWORD dwFileAttributes)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::SetFileAttributesW(lpFileName,dwFileAttributes);

	return ::SetFileAttributesA(Buf8<MAX_PATH>(lpFileName),dwFileAttributes);

	}

/**

This function wraps the Win32 SetVolumeLabel API (see http://msdn2.microsoft.com/en-us/library/aa365560.aspx).

*/

EXPORT_C BOOL Emulator::SetVolumeLabel(LPCWSTR lpRootPathName,LPCWSTR lpVolumeName)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::SetVolumeLabelW(lpRootPathName,lpVolumeName);

	return ::SetVolumeLabelA(Buf8<MAX_PATH>(lpRootPathName),Buf8<MAX_PATH>(lpVolumeName));

	}

/**

Maps an NT error to an Epoc32 error.

@return	 Last-error code of the calling thread.

*/

EXPORT_C TInt Emulator::LastError()

// For other error codes look at MSDN "Numerical List of Error Codes"

	{

	switch (GetLastError())

		{

	case ERROR_SUCCESS:				return KErrNone;

	case ERROR_INVALID_DRIVE:		return KErrNotReady;

	case ERROR_INVALID_NAME:

	case ERROR_FILENAME_EXCED_RANGE:

	case ERROR_OPEN_FAILED:			return KErrBadName; 

	case ERROR_INVALID_HANDLE:		return KErrBadHandle;

	case ERROR_NOT_SUPPORTED:

	case ERROR_INVALID_FUNCTION:	return KErrNotSupported;

	case ERROR_SHARING_VIOLATION: 

	case ERROR_ACCESS_DENIED: 

	case ERROR_WRITE_PROTECT:		return KErrAccessDenied;

	case ERROR_LOCK_VIOLATION:		return KErrLocked;

	case ERROR_FILE_NOT_FOUND:

	case ERROR_MOD_NOT_FOUND:		return KErrNotFound;

	case ERROR_DIRECTORY: 

	case ERROR_BAD_PATHNAME:

	case ERROR_PATH_NOT_FOUND:		return KErrPathNotFound; 

	case ERROR_ALREADY_EXISTS:

	case ERROR_FILE_EXISTS:			return KErrAlreadyExists;

	case ERROR_NOT_READY:			return KErrNotReady; 

	case ERROR_UNRECOGNIZED_VOLUME:

	case ERROR_NOT_DOS_DISK:		return KErrUnknown;

	case ERROR_UNRECOGNIZED_MEDIA:

	case ERROR_BAD_EXE_FORMAT:		return KErrCorrupt;

	case ERROR_NO_MORE_FILES:		return KErrEof; 

	case ERROR_DIR_NOT_EMPTY:		return KErrInUse;

	case ERROR_INVALID_USER_BUFFER:

	case ERROR_NOT_ENOUGH_MEMORY:

	case ERROR_INSUFFICIENT_BUFFER:

	case ERROR_OUTOFMEMORY:			return KErrNoMemory;

	case ERROR_DISK_FULL:			return KErrDiskFull;

	case ERROR_INVALID_DATA:

	case ERROR_INVALID_PARAMETER:	return KErrArgument;

	case ERROR_OPERATION_ABORTED:	return KErrCancel;

    default:						return KErrGeneral;

		}

	}

/**

This function wraps the Win32 GetProcAddress API (see http://msdn2.microsoft.com/en-us/library/ms683212.aspx).

*/

FARPROC Emulator::GetProcAddress(HMODULE hModule, LPCSTR lpProcName)

	{

	__LOCK_HOST;

	return ::GetProcAddress(hModule, lpProcName);

	}

// image file support

// loaded modules

/**

Gets the header format of the file system.

@return		Returns the header format of the file system.	

*/

EXPORT_C const IMAGE_NT_HEADERS32* Emulator::TModule::NtHeader() const

	{

	if (!IsValid())

		return 0;

	const IMAGE_DOS_HEADER* dhead = (const IMAGE_DOS_HEADER*)Translate(0);

	if ( IMAGE_DOS_SIGNATURE != dhead->e_magic )

		return 0;

	if (dhead->e_lfarlc < sizeof(IMAGE_DOS_HEADER))

		return 0;

	const IMAGE_NT_HEADERS32* ntHead = (const IMAGE_NT_HEADERS32*)Translate(dhead->e_lfanew);

    if ( ntHead->Signature != IMAGE_NT_SIGNATURE )

		return 0;

	return ntHead;

	}

/**

Constructor which sets the handles of loaded module to the specified module.

@param aModuleName		Holds the name of the module to be loaded.

*/

EXPORT_C Emulator::TModule::TModule(LPCSTR aModuleName)

	: iModule(GetModuleHandleA(aModuleName)), iBase(iModule)

	{

	if (!NtHeader())

		{

		iModule = 0;

		iBase = 0;

		}

	}

/**

Gets the pointer of the section header if the header name matches with the buffer aSection[].

@param aSection[]	A buffer of type BYTE.		

@return 	Returns the pointer to section header of the file system.

*/

EXPORT_C const IMAGE_SECTION_HEADER* Emulator::TModule::SectionHeader(const BYTE aSection[]) const

	{

	const IMAGE_NT_HEADERS32* ntHead = NtHeader();

	if (!ntHead)

		return 0;

	const IMAGE_SECTION_HEADER* imgHead = (const IMAGE_SECTION_HEADER*)((TUint8*)&ntHead->OptionalHeader + ntHead->FileHeader.SizeOfOptionalHeader);

	const IMAGE_SECTION_HEADER* end = imgHead + ntHead->FileHeader.NumberOfSections;

	for (; imgHead < end; ++imgHead)

		{

		if (memcmp(imgHead->Name, aSection, IMAGE_SIZEOF_SHORT_NAME)==0)

			return imgHead;

		}

	return 0;

	}

/**

Points to the first byte or first page of the loaded module or mapped file image.

@param aSection[]	A buffer of type BYTE.

@return TAny		Returns first byte of the loaded module or first page of the mapped file image.

*/

EXPORT_C const TAny* Emulator::TModule::Section(const BYTE aSection[]) const

	{

	const IMAGE_SECTION_HEADER* imgHead = SectionHeader(aSection);

	if (imgHead)

		return Translate(IsLoaded() ? imgHead->VirtualAddress : imgHead->PointerToRawData);

	return 0;

	}

/**

Go through the section headers looking for UID section.

@param aType	Contains a UID type.

*/

EXPORT_C void Emulator::TModule::GetUids(TUidType& aType) const

	{

	const TEmulatorImageHeader* hdr = (const TEmulatorImageHeader*)Section(KWin32SectionName_Symbian);

	if (hdr)

		aType = *(const TUidType*)&hdr->iUids[0];

	}

/**

Goes through section headers and gets the information of file system.

@param aInfo	Contains the information of the file system.

*/

EXPORT_C void Emulator::TModule::GetInfo(TProcessCreateInfo& aInfo) const

	{

	aInfo.iExceptionDescriptor = 0;

	const IMAGE_NT_HEADERS32* ntHead = NtHeader();

	if (ntHead)

		{

		const TEmulatorImageHeader* hdr = (const TEmulatorImageHeader*)Section(KWin32SectionName_Symbian);

		if (hdr)

			{

			aInfo.iUids = *(const TUidType*)&hdr->iUids[0];

			TBool isExe = (hdr->iUids[0].iUid==KExecutableImageUidValue);

			TBool data_section_present = (Section(KWin32SectionName_EpocData)!=NULL);

			TBool data = hdr->iFlags & KEmulatorImageFlagAllowDllData;

			if (data_section_present && isExe)

				data = ETrue;

			aInfo.iBssSize=data?1:0;

			aInfo.iDataSize=0;

			aInfo.iTotalDataSize=aInfo.iBssSize;

			aInfo.iDepCount = 0;

			aInfo.iHeapSizeMin = ntHead->OptionalHeader.SizeOfHeapCommit;

			aInfo.iHeapSizeMax = ntHead->OptionalHeader.SizeOfHeapReserve;

			aInfo.iStackSize = 0x1000;

			aInfo.iPriority = hdr->iPriority;

			aInfo.iHandle = NULL;

			aInfo.iS = hdr->iS;

			aInfo.iModuleVersion = hdr->iModuleVersion;

			if (ntHead->FileHeader.Characteristics & IMAGE_FILE_DLL)

				aInfo.iAttr |= ECodeSegAttHDll;

			}

		}

	GetUids(aInfo.iUids);

	}

/**

Finds the import section from the data directory. This relies on the module being loaded.

@return 	Returns the imported executable.

*/

EXPORT_C const IMAGE_IMPORT_DESCRIPTOR* Emulator::TModule::Imports() const

	{

	if (!IsLoaded())

		return NULL;

	const IMAGE_NT_HEADERS32* ntHead = NtHeader();

	if (!ntHead)

		return NULL;

	DWORD va = ntHead->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;

	if (!va)

		return NULL;

	return (const IMAGE_IMPORT_DESCRIPTOR*)Translate(va);

	}

// modules in the file system

EXPORT_C TInt Emulator::RImageFile::Open(LPCTSTR aImageFile)

	{

	Buf8<MAX_PATH>   nameBuf(aImageFile);

	char *pName = (char *)strrchr(LPCSTR(nameBuf), '\\');

	pName ? ++pName : pName = (char *)LPCSTR(nameBuf);

	__LOCK_HOST;

	iMapping = OpenFileMapping(FILE_MAP_READ, FALSE, (LPCTSTR)pName);

	if (!iMapping)

		{

		if (pName == (char *)LPCSTR(nameBuf))

			iModule = Emulator::GetModuleHandle(aImageFile);

		if (iModule)

			iBase = iModule;

		else

			{

			// need to map the file instead

			HANDLE file = Emulator::CreateFile(aImageFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

			if (file == INVALID_HANDLE_VALUE)

				return LastError();

			iMapping = CreateFileMappingA(file, NULL, PAGE_READONLY, 0, 0, pName);

			CloseHandle(file);

			}

		}

	if (!iModule)

		{

		if (!iMapping)

			return LastError();

		iBase = MapViewOfFile(iMapping, FILE_MAP_READ, 0, 0, 0);

		if (!iBase)

			{

			CloseHandle(iMapping);

			iMapping = 0;

			return LastError();

			}

		}

	if (!NtHeader())

		{

		Close();

		return KErrNotSupported;

		}

	return KErrNone;

	}

EXPORT_C void Emulator::RImageFile::Close()

	{

	if (iMapping)

		{

		UnmapViewOfFile(iBase);

		CloseHandle(iMapping);

		iMapping = 0;

		}

	iBase = 0;

	iModule = 0;

	}