// Copyright (c) 1996-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:

// e32tools/e32image/tr_main.cpp

// Translate X->E32Image top level

// 

//

#ifndef __LINUX__

  #include <io.h>

#endif

#include <string.h>

#ifdef __VC32__

 #ifdef __MSVCDOTNET__

  #include <strstream>

  #include <iomanip>

 #else //!__MSVCDOTNET__

  #include <strstrea.h>

  #include <iomanip.h>

 #endif //__MSVCDOTNET__

#else // !__VC32__*/

#ifdef __TOOLS2__

  #include <sstream>

  #include <iomanip>

  #else

 #include <strstream.h>

 #include <iomanip.h>

#endif // __VC32__

#endif

#include <e32std.h>

#include <e32std_private.h>

#ifdef __SUPPORT_PE_FILES__

#include "pe_file.h"

#endif

#ifdef __SUPPORT_ELF_FILES__

#include "elftran.h"

#endif

#include "h_utl.h"

#include "h_ver.h"

#include <stdio.h>

extern int gAlignConstSection;

extern TUint gConstSectionAddressMask;

int gVerbose=0;

char *gFile1=NULL;

char *gFile2=NULL;

unsigned int gStack=0;

unsigned int gHeapMin=0;

unsigned int gHeapMax=0;

TUid gUid1=KNullUid;

TUid gUid2=KNullUid;

TUid gUid3=KNullUid;

unsigned int gSecureId=0;

unsigned int gVendorId=0;

unsigned int gVersionWord=0x00010000u;

int gCallEntryPoints=TRUE;

int gFixedAddress=FALSE;

int gPriority=EPriorityForeground;

SCapabilitySet gCapability={0};

int gAllowDllData=FALSE;

// fix warning for Linux warning: 0 instead of NULL

TUint gDataBase=0;

int gCompress=TRUE;

unsigned int gFPU=0;

int gCodePaged=FALSE;

int gCodeUnpaged=FALSE;

int gCodeDefaultPaged=FALSE;

int gDataPaged=FALSE;

int gDataUnpaged=FALSE;

int gDataDefaultPaged=FALSE;

int gDebuggable=FALSE;

int gSmpSafe=FALSE;

int gSetStack=FALSE;

int gSetHeap=FALSE;

int gSetUid1=FALSE;

int gSetUid2=FALSE;

int gSetUid3=FALSE;

int gSetCallEntryPoints=FALSE;

int gSetFixedAddress=FALSE;

int gSetPriority=FALSE;

int gSetCapability=FALSE;

int gSetCompress=FALSE;

int gSetVersion=FALSE;

int gSetSecureId=FALSE;

int gSetVendorId=FALSE;

int gSetFPU=FALSE;

int gSetCodePaged=FALSE;

int gSetDataPaged=FALSE;

int gSetSymLkup=FALSE;

int gSetDebuggable=FALSE;

int gSetSmpSafe=FALSE;

enum CompressionMethods

{

	ENoCompression = 0,

	EDeflate = 1,

	EBytePair = 2,

};

int gCompressionMethod = EDeflate;

int gSuppressComprMethod = FALSE;

#ifdef __SUPPORT_PE_FILES__

char* gX86imp=NULL;

int gX86num_imp_dlls=0;

int gX86imp_size=0;

int gX86num_imports=0;

#endif

TBool gLittleEndian=ETrue;

class E32ImageFileRef

	{

public:

	E32ImageFileRef() {iPtr = E32ImageFile::New();}

	~E32ImageFileRef() {delete iPtr;}

	class E32ImageFile& Ref() {return *iPtr;}

private:

	E32ImageFileRef(const E32ImageFileRef&);

	E32ImageFileRef& operator=(const E32ImageFileRef&);

private:

	E32ImageFile* iPtr;

	};

int setPagedFlags(E32ImageFile& f)

	{

	unsigned check1 = gCodePaged + gCodeUnpaged + gCodeDefaultPaged;

	unsigned check2 = gDataPaged + gDataUnpaged + gDataDefaultPaged;

	if (check1 > 1 || check2 > 1)

		{

		Print(EError, "Conflicting paging options.\n");

		return KErrArgument;

		}

	if (gCodePaged)

		{

		f.iHdr->iFlags |= KImageCodePaged;

		f.iHdr->iFlags &= ~KImageCodeUnpaged;

		}

	else if (gCodeUnpaged)

		{

		f.iHdr->iFlags |= KImageCodeUnpaged;

		f.iHdr->iFlags &= ~KImageCodePaged;

		}

	else if (gCodeDefaultPaged)

		{

		f.iHdr->iFlags &= ~KImageCodePaged;

		f.iHdr->iFlags &= ~KImageCodeUnpaged;

		}

	if (gDataPaged)

		{

		f.iHdr->iFlags |=  KImageDataPaged;

		f.iHdr->iFlags &= ~KImageDataUnpaged;

		}

	else if (gDataUnpaged)

		{

		f.iHdr->iFlags |=  KImageDataUnpaged;

		f.iHdr->iFlags &= ~KImageDataPaged;

		}

	else if (gDataDefaultPaged)

		{

		f.iHdr->iFlags &= ~KImageDataPaged;

		f.iHdr->iFlags &= ~KImageDataUnpaged;

		}

	return KErrNone;

	}

void setDebuggableFlags(E32ImageFile& f)

	{

	if (gDebuggable)

		{

		f.iHdr->iFlags |= KImageDebuggable;

		}

	else

		{

		f.iHdr->iFlags &= ~KImageDebuggable;

		}

	}

void setSmpSafeFlags(E32ImageFile& f)

	{

	if (gSmpSafe)

		{

		f.iHdr->iFlags |= KImageSMPSafe;

		}

	else

		{

		f.iHdr->iFlags &= ~KImageSMPSafe;

		}

	}

int dotran(const char* ifilename, const char* ofilename)

	{

	E32ImageFileRef fRef;

	E32ImageFile& f = fRef.Ref();

	int r=f.Translate(ifilename, gDataBase, gAllowDllData, gSetSymLkup);

	if (r!=KErrNone)

		return r;

	if (gSetStack)

		f.SetStackSize(gStack);

	if (gSetHeap)

		{

		f.SetHeapSizeMin(gHeapMin);

		f.SetHeapSizeMax(gHeapMax);

		}

	if (!gSetUid1)

		gUid1=TUid::Uid(f.iHdr->iUid1);

	if (!gSetUid2)

		gUid2=TUid::Uid(f.iHdr->iUid2);

	if (!gSetUid3)

		gUid3=TUid::Uid(f.iHdr->iUid3);

	if (!gSetSecureId)

		gSecureId = f.iHdr->iUid3;

	if (!gSetVendorId)

		gVendorId = 0;

	f.SetUids(gUid1, gUid2, gUid3);

	f.SetSecureId(gSecureId);

	f.SetVendorId(gVendorId);

	if (gSetCallEntryPoints)

		f.SetCallEntryPoints(gCallEntryPoints);

	if (gSetCapability)

		f.SetCapability(gCapability);

	if (gSetPriority)

		{

		if (f.iHdr->iFlags&KImageDll)

			Print(EWarning,"Cannot set priority of a DLL.\n");

		else

			f.SetPriority((TProcessPriority)gPriority);

		}

	if (gSetFixedAddress)

		{

		if (f.iHdr->iFlags&KImageDll)

			Print(EWarning,"Cannot set fixed address for DLL.\n");

		else

			f.SetFixedAddress(gFixedAddress);

		}

	if (gSetVersion)

		f.iHdr->iModuleVersion = gVersionWord;

	if(gCompress)

	{

		switch(gCompressionMethod)

		{

			case ENoCompression:

				f.iHdr->iCompressionType = KFormatNotCompressed;

				break;

			case EDeflate:

				f.iHdr->iCompressionType = KUidCompressionDeflate;

				break;

			case EBytePair:

				f.iHdr->iCompressionType = KUidCompressionBytePair;

				break;

			default:

				Print(EError, "Unknown compression method:%d", gCompressionMethod);

				return 1;

		} // End of switch()

	}

	else

	{

		f.iHdr->iCompressionType = KFormatNotCompressed;		

	}

	if (gSetFPU)

		f.SetFPU(gFPU);

	r = setPagedFlags(f);

	if (r != KErrNone)

	{

		return r;

	}

	setDebuggableFlags(f);

	setSmpSafeFlags(f);

	f.CreateExportBitMap();

	f.AddExportDescription();

	f.UpdateHeaderCrc();

	r = f.Validate();

	if (r!=KErrNone)

		return r;

	ofstream ofile(ofilename, ios::binary);

	if (!ofile)

		{

		Print(EError,"Cannot open %s for output.\n",ofilename);

		return 1;

		}

	ofile << f;

	ofile.close();

	if (gVerbose)

		f.Dump((TText*)ofilename,gVerbose);

	return KErrNone;

	}

int dodump(const char* ifilename)

	{

	E32ImageFile f;

	TInt r = f.Open(ifilename);

	if (r>0)

		return 1;

	else if (r==KErrCorrupt || r==KErrNotSupported)

		{

		Print(EError,"%s is not a valid E32Image file.\n",ifilename);

		return 1;

		}

	else if (r!=0)

		{

		Print(EError,"Error %d reading %s.\n",r,ifilename);

		return 1;

		}

	f.Dump((TText*)ifilename, gVerbose ? gVerbose : E32ImageFile::EDumpDefaults);

	return KErrNone;

	}

int doalter(const char* ifilename)

	{

	E32ImageFile f;

	TInt r = f.Open(ifilename);

	if (r>0)

		return 1;

	else if (r==KErrCorrupt || r==KErrNotSupported)

		{

		Print(EError,"%s is not a valid E32Image file.\n",ifilename);

		return 1;

		}

	else if (r!=0)

		{

		Print(EError,"Error %d reading %s.\n",r,ifilename);

		return 1;

		}

	TUint hdrfmt = f.iHdr->HeaderFormat();

	if (hdrfmt != KImageHdrFmt_V)

		{

		Print(EError,"Can't modify old format binaries\n");

		return 1;

		}

	if (gDataBase)

		{

		Print(EWarning, "Ignoring -datalinkaddress Switch");

		}

	if (gSetStack)

		f.SetStackSize(gStack);

	if (gSetHeap)

		{

		f.SetHeapSizeMin(gHeapMin);

		f.SetHeapSizeMax(gHeapMax);

		}

	if (!gSetUid1)

		gUid1=TUid::Uid(f.iHdr->iUid1);

	if (!gSetUid2)

		gUid2=TUid::Uid(f.iHdr->iUid2);

	if (!gSetUid3)

		gUid3=TUid::Uid(f.iHdr->iUid3);

	f.SetUids(gUid1, gUid2, gUid3);

	if (gSetSecureId)

		f.SetSecureId(gSecureId);

	if (gSetVendorId)

		f.SetVendorId(gVendorId);

	if (gSetCallEntryPoints)

		f.SetCallEntryPoints(gCallEntryPoints);

	if (gSetCapability)

		f.SetCapability(gCapability);

	if (gSetPriority)

		{

		if (f.iHdr->iFlags&KImageDll)

			Print(EWarning,"Cannot set priority of a DLL.\n");

		else

			f.SetPriority((TProcessPriority)gPriority);

		}

	if (gSetFixedAddress)

		{

		if (f.iHdr->iFlags&KImageDll)

			Print(EWarning,"Cannot set fixed address for DLL.\n");

		else

			f.SetFixedAddress(gFixedAddress);

		}

	if (gSetVersion)

		f.iHdr->iModuleVersion = gVersionWord;

	if(gCompress)

	{

		switch(gCompressionMethod)

		{

			case ENoCompression:

				f.iHdr->iCompressionType = KFormatNotCompressed;

				break;

			case EDeflate:

				f.iHdr->iCompressionType = KUidCompressionDeflate;

				break;

			case EBytePair:

				f.iHdr->iCompressionType = KUidCompressionBytePair;

				break;

			default:

				Print(EError, "Unknown compression method:%d", gCompressionMethod);

				return 1;

		} // End of switch()

	}

	else

		f.iHdr->iCompressionType = KFormatNotCompressed;

	if (gSetFPU)

		f.SetFPU(gFPU);

	r = setPagedFlags(f);

	if (r != KErrNone)

	{

		return r;

	}

	setDebuggableFlags(f);

	setSmpSafeFlags(f);

	f.UpdateHeaderCrc();

	r = f.Validate();

	if (r!=KErrNone)

		return r;

	ofstream ofile(ifilename, ios::binary);

	if (!ofile)

		{

		Print(EError,"Cannot open %s for output.\n",ifilename);

		return 1;

		}

	ofile << f;

	ofile.close();

	if (gVerbose)

		f.Dump((TText *)ifilename,gVerbose);

	return KErrNone;

	}

int helpme(char *aStr)

	{

	Print(EAlways,"Syntax: %s [options] inputfile outputfile\n",aStr);

	Print(EAlways,"        %s [options] e32imagefile\n",aStr);

	Print(EAlways,"option: [-v] [[-no]call[entrypoint]] [-priority <priority>]\n");

	Print(EAlways,"        [-stack <size>] [-heap <min> <max>] [-uid<n> <uid>]\n");

	Print(EAlways,"        [-allowdlldata] [-datalinkaddress <base>] [-fixed] [-moving]\n");

	Print(EAlways,"        [-align-const-section] [-const-section-address-mask <mask>]\n");

	Print(EAlways,"        [-[no]compress] [-compressionmethod none|deflate|bytepair]\n");

	Print(EAlways,"        [-capability \"<list>\"] [-version M.m] [-vid <id>]\n");

	Print(EAlways,"        [-fpu <softvfp|vfpv2>]\n");

	Print(EAlways,"        [-codepaging <paged|unpaged|default>]\n");

	Print(EAlways,"        [-datapaging <paged|unpaged|default>]\n");

	Print(EAlways,"        [-debuggable]\n");

	Print(EAlways,"        [-smpsafe]\n");

	Print(EAlways,"        [-sym_name_lkup]\n");

	Print(EAlways,"        [-dump [h][s][c][d][e][i]]\n");

	Print(EAlways,"flags for dump: h Header\n");

	Print(EAlways,"                s Security info\n");

	Print(EAlways,"                c Code section\n");

	Print(EAlways,"                d Data section\n");

	Print(EAlways,"                e Export info\n");

	Print(EAlways,"                i Import table\n");

	return KErrArgument;

	}

int isNumber(char *aStr)

	{

	return (aStr[0]>='0') && (aStr[0]<='9');

	}

int getUIntArg(unsigned int &aVal, int argc, char *argv[], int i)

	{

	if (i>=argc)

		return KErrArgument;

	if (!isNumber(argv[i]))

		return KErrArgument;

#ifdef __LINUX__

	int n;

	sscanf(argv[i], "%i", &n);

	aVal = n;

#else

#ifdef __TOOLS2__

istringstream s(argv[i]/*, strlen(argv[i])*/);

#else

istrstream s(argv[i], strlen(argv[i]));

#endif

#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)

	s >> setbase(0);

#endif //__MSVCDOTNET__

	s >> aVal;

#endif // __LINUX__

	return KErrNone;