/*

* Copyright (c) 1995-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: 

*

*/

#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 

#endif //__VC32__

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <assert.h>

#include "e32std.h"

#include "e32std_private.h"

#include "e32rom.h"

#include "u32std.h"

#include "r_rom.h"

#include "r_obey.h"

#include "r_global.h"

#include "h_utl.h"

#include "patchdataprocessor.h"

#include "r_coreimage.h"

#define _P(word)	word, sizeof(word)-1	// match prefix, optionally followed by [HWVD]

#define _K(word)	word, 0					// match whole word

const ObeyFileKeyword ObeyFileReader::iKeywords[] =

{

	{_P("file"),		2,-2, EKeywordFile, "Executable file to be loaded into the ROM"},

	{_P("data"),		2,-2, EKeywordData, "Data file to be copied into the ROM"},

	{_P("primary"),		1+2,-2, EKeywordPrimary, "An EPOC Kernel"},

	{_P("secondary"),	2,-2, EKeywordSecondary, "?"},

	{_P("variant"),		1+2,-2, EKeywordVariant, "?"},

	{_P("extension"),	1+2,-2, EKeywordExtension, "Kernel extension loaded before the secondary"},

	{_P("device"),		1+2,-2, EKeywordDevice, "Kernel extension loaded from the ROM file system"},

	{_P("dll"),			2,-2, EKeywordDll, "Executable file whose entry point must be called"},

	{_P("filecompress"),	2,-2, EKeywordFileCompress, "Non-XIP Executable to be loaded into the ROM compressed"},

	{_P("fileuncompress"),	2,-2, EKeywordFileUncompress, "Non-XIP Executable to be loaded into the ROM uncompressed"},

	{_K("area"),	    1, 3, EKeywordArea, "Declare a relocation area"},

	{_K("align"),	    2, 1, EKeywordAlign, "Override default alignment for following file"},

	{_P("hide"),	    2, -1, EKeywordHide, "Exclude named file from ROM directory structure"},

	{_P("alias"),	    2, -2, EKeywordAlias, "Create alias for existing file in ROM directory structure"},

	{_P("rename"),	    2, -2, EKeywordRename, "Change the name of a file in the ROM directory structure"},

	{_K("singlekernel"),1, 0, EKeywordSingleKernel, "Single Kernel"},

	{_K("multikernel"),	1, 0, EKeywordMultiKernel, "Multiple Kernels"},

	{_K("bootbinary"),	1, 1, EKeywordBootBinary, "file containing the bootstrap"},

	{_K("romname"),		1, 1, EKeywordRomName, "output file for ROM image"},

	{_K("romsize"),		1, 1, EKeywordRomSize, "size of ROM image"},

	{_K("romlinearbase"),	1, 1, EKeywordRomLinearBase, "linear address of ROM image"},

	{_K("romalign"),	1, 1, EKeywordRomAlign, "default alignment of files in ROM image"},

	{_K("romchecksum"),	1, 1, EKeywordRomChecksum, "desired 32-bit checksum value for the whole ROM image"},

	{_K("kerneldataaddress"),	1, 1, EKeywordKernelDataAddress, "?"},

	{_K("kernelheapmin"),	1, 1, EKeywordKernelHeapMin, "Inital size of the kernel heap"},

	{_K("kernelheapmax"),	1, 1, EKeywordKernelHeapMax, "Maximum size of the kernel heap"},

	{_K("dataaddress"),	1, 1, EKeywordDataAddress, "?"},

	{_K("defaultstackreserve"),	1, 1, EKeywordDefaultStackReserve, "?"},

	{_K("version"),		1, 1, EKeywordVersion, "ROM version number"},

	{_K("romnameodd"),	1, 1, EKeywordRomNameOdd, "output file containing odd halfwords of ROM image"},

	{_K("romnameeven"),	1, 1, EKeywordRomNameEven, "output file containing even halfwords of ROM image"},

	{_K("srecordfilename"),	1, 1, EKeywordSRecordFileName, "output file containing ROM image in S-Record format"},

	{_K("srecordbase"),	1, 1, EKeywordSRecordBase, "Destination address for S-Record download"},

	{_K("kerneltrace"),	1, -1, EKeywordKernelTrace, "Initial value for Kernel tracing flags"},

	{_K("btrace"),	1, -1, EKeywordBTrace, "Initial value for fast-trace filter"},

	{_K("btracemode"),	1, 1, EKeywordBTraceMode, "Initial value for fast-trace mode"},

	{_K("btracebuffer"),	1, 1, EKeywordBTraceBuffer, "Initial size for fast-trace buffer"},

	{_K("collapse"),	1, 3, EKeywordCollapse, "Additional ROM optimisations"},

	{_K("time"),	    1,-1, EKeywordTime, "ROM timestamp"},

	{_K("section"),	    2, 1, EKeywordSection, "Start of replaceable section in old-style 2 section ROM"},

	{_K("extensionrom"),1+2, 1, EKeywordExtensionRom, "Start of definition of optional Extension ROM"},

	{_K("kernelromname"),1, 1, EKeywordKernelRomName, "ROM image on which extension ROM is based"},

	{_K("files"),		0, 0, EKeywordNone, 0},	// backwards compatibility, but now ignored

	{_K("rem"),			0, 0, EKeywordNone, "comment"},

	{_K("stop"),		0, 0, EKeywordNone, "Terminates OBEY file prematurely"},

	{_K("dlldatatop"),	1, 1, EKeywordDllDataTop, "Specify top of DLL data region"},

	{_K("memmodel"),	1, -1, EKeywordMemModel, "Specifies the memory model to be used at runtime"},

	{_K("nowrapper"),	1, 0, EKeywordNoWrapper, "Specifies that no ROM wrapper is required"},

	{_K("epocwrapper"),	1, 0, EKeywordEpocWrapper, "Specifies that an EPOC ROM wrapper is required"},

	{_K("coffwrapper"),	1, 0, EKeywordCoffWrapper, "Specifies that a COFF ROM wrapper is required"},

	{_K("platsecenforcement"),	1, 1, EKeywordPlatSecEnforcement, "Set Platform Security enforment on/off"},

	{_K("platsecdiagnostics"),	1, 1, EKeywordPlatSecDiagnostics, "Set Platform Security diagnostics on/off"},

	{_K("platsecprocessisolation"), 1, 1, EKeywordPlatSecProcessIsolation, "Set Platform Security process isolation on/off"},

	{_K("platsecenforcesysbin"), 1, 1, EKeywordPlatSecEnforceSysBin, "Set Platform Security process isolation on/off"},

	{_K("platsecdisabledcaps"), 1, 1, EKeywordPlatSecDisabledCaps, "Disable the listed Platform Security capabilities"},

	{_K("pagingpolicy"),	1, 1, EKeywordPagingPolicy, "Set the demand paging policy NOPAGING|DEFAULTUNPAGED|DEFAULTPAGED"},

	{_K("codepagingpolicy"),	1, 1, EKeywordCodePagingPolicy, "Set the code paging policy NOPAGING|DEFAULTUNPAGED|DEFAULTPAGED"},

	{_K("datapagingpolicy"),	1, 1, EKeywordDataPagingPolicy, "Set the data paging policy NOPAGING|DEFAULTUNPAGED|DEFAULTPAGED"},

	{_K("pagingoverride"),	1, 1, EKeywordPagingOverride, "Overide the demand paging attributes for every file in ROM, NOPAGING|DEFAULTUNPAGED|DEFAULTPAGED"},

	{_K("codepagingoverride"),	1, 1, EKeywordCodePagingOverride, "Overide the code paging attributes for every file in ROM, NOPAGING|DEFAULTUNPAGED|DEFAULTPAGED"},

	{_K("datapagingoverride"),	1, 1, EKeywordDataPagingOverride, "Overide the data paging attributes for every file in ROM, NOPAGING|DEFAULTUNPAGED|DEFAULTPAGED"},

	{_K("patchdata"), 2, 5, EKeywordPatchDllData, "Patch exported data"},

	{_K("coreimage"),	1, 1, EKeywordCoreImage, "Core image to be used for extension directory structure"},

	// things we don't normally report in the help information

	{_K("trace"),		1, 1, EKeywordTrace, "(ROMBUILD activity trace flags)"},

	{_K("unicode"),		1, 0, EKeywordUnicode, "(UNICODE rom - the default)"},

	{_K("ascii"),		1, 0, EKeywordAscii, "(Narrow rom)"},

	{_K("languages"),	1,-1, EKeywordLanguages, "(List of supported languages (for test))"},

	{_K("hardware"),	1, 1, EKeywordHardware, "(32-bit Hardware identifier (for test))"},

	{_K("debugport"),	1, 1, EKeywordDebugPort, "(Debug trace sink (magic cookie passed to ASSP/variant))"},

	{_K("compress"),	1, 0, EKeywordCompress, "Compress the ROM image"},

	{_K("demandpagingconfig"),	1, -1, EKeywordDemandPagingConfig, "Demand Paging Config [minPages] [maxPages] [ageRatio]"},

	{_K("pagedrom"),	1, 0, EKeywordPagedRom, "Build ROM immage suitable for demand paging"},

	{_K("filecompressnone"), 		2, -2, EKeywordExecutableCompressionMethodNone, "No compress the individual executable image."},

	{_K("filecompressinflate"),     2, -2, EKeywordExecutableCompressionMethodInflate,  "Inflate compression method for the individual executable image."},

	{_K("filecompressbytepair"),  	2, -2, EKeywordExecutableCompressionMethodBytePair, "Byte pair compresion method for the individual executable image."},

	{_K("kernelconfig"), 1, 2, EKeywordKernelConfig, "Set an arbitrary bit of the kernel config flags to on/off)"},

	{_K("maxunpagedsize"),	1, 1, EKeywordMaxUnpagedMemSize, "Maxinum unpaged size in ROM image. Default is no limited."},

	{_K("hcrdata") , 2, 2,EKeywordHardwareConfigRepositoryData,"HCR image data"},

	{0,0,0,0,EKeywordNone,""} 

};

void ObeyFileReader::KeywordHelp() // static

	{

	cout << "Obey file keywords:\n";

	const ObeyFileKeyword* k=0;

	for (k=iKeywords; k->iKeyword!=0; k++)

		{

		if (k->iHelpText==0)

			continue;

		if (k->iHelpText[0]=='(' && !H.iVerbose)

			continue;	// don't normally report things in (parentheses)

		char buf[32];

		sprintf(buf, "%-20s", k->iKeyword);

		if (k->iKeywordLength)

			memcpy(buf+k->iKeywordLength,"[HWVD]",6);

		if (H.iVerbose)

			sprintf(buf+20,"%2d",k->iNumArgs);

		cout << "    " << buf << " " << k->iHelpText << endl;

		}

	cout << endl;

	cout << "File attributes:\n";

	const FileAttributeKeyword* f=0;

	for (f=iAttributeKeywords; f->iKeyword!=0; f++)

		{

		if (f->iHelpText==0)

			continue;

		if (f->iHelpText[0]=='(' && !H.iVerbose)

			continue;	// don't normally report things in (parentheses)

		char buf[32];

		sprintf(buf, "%-20s", f->iKeyword);

		if (H.iVerbose)

			sprintf(buf+20,"%2d",k->iNumArgs);

		cout << "    " << buf << " " << f->iHelpText << endl;

		}

	cout << endl;

	}

TInt NumberOfVariants=0;

ObeyFileReader::ObeyFileReader(TText* aFileName):

//

// Constructor

//

	iMark(0), iMarkLine(0), iCurrentMark(0), iCurrentLine(0), imaxLength(0),iSuffix(0),iLine(0)

	{

	iFileName = new TText[strlen((const char *)aFileName)+1];

	strcpy((char *)iFileName,(const char *)aFileName);

	}

ObeyFileReader::~ObeyFileReader()

	{

	if (iObeyFile)

		fclose(iObeyFile);

	iObeyFile=0;

	delete [] iFileName;

	delete [] iLine;

	}

TBool ObeyFileReader::Open()

//

// Open the file & return a status

//

	{

 	iObeyFile = fopen((const char *)iFileName,"r");

	if (!iObeyFile)

		{

		Print(EError,"Cannot open obey file %s\n",iFileName);

		return EFalse;

		}

	if (SetLineLengthBuffer() != KErrNone)

	 	{

		Print(EError,"Insufficent Memory to Continue.");	

	 	return EFalse;

		}

	return ETrue;

	}

TInt ObeyFileReader::SetLineLengthBuffer()

// Get the Max Line length for the given obey file and allocate the buffer.

	{

	char ch = '\0';

	TInt length = 0;

	Rewind();

	while ((ch = (char)fgetc(iObeyFile)) != EOF)

		{

		length++;

		if (ch == '\n')

			{

			if (length > imaxLength)

				imaxLength = length;

			length = 0;				

			}

		}

	if (length > imaxLength)

		imaxLength = length;

	if (0 == imaxLength)

		{

		Print(EError,"Empty obey file passed as input.");

		exit(-1);

		}			

	else if (imaxLength < 2)

		{

		Print(EError,"Invalid obey file passed as input.");

		exit(-1);

		}

	Rewind();

	iLine = new TText[imaxLength+1];

	if(!iLine)

		return KErrNoMemory;

	return KErrNone;

	}

void ObeyFileReader::Mark()

	{

	iMark = iCurrentMark;

	iMarkLine = iCurrentLine-1;

	}

void ObeyFileReader::MarkNext()

	{

	iMark = ftell(iObeyFile);

	iMarkLine = iCurrentLine;

	}

void ObeyFileReader::Rewind()

	{

	fseek(iObeyFile,iMark,SEEK_SET);

	iCurrentMark = iMark;

	iCurrentLine = iMarkLine;

	}

void ObeyFileReader::CopyWord(TInt aIndex, TText*& aString)

	{

	aString = new TText[strlen((const char *)iWord[aIndex])+1];

	strcpy((char *)aString, (const char *)iWord[aIndex]);

	}

TInt ObeyFileReader::ReadAndParseLine()

	{

	if (feof(iObeyFile))

		return KErrEof;

	iCurrentLine++;

	iCurrentMark = ftell(iObeyFile);

	iLine[0]='\0';

	char * cp = fgets((char*)iLine,imaxLength+1,iObeyFile); (void)cp;

	iNumWords = Parse();

	return KErrNone;

	}

TInt ObeyFileReader::NextLine(TInt aPass, enum EKeyword& aKeyword)

	{

NextLine:

	TInt err = ReadAndParseLine();

	if (err == KErrEof)

		return KErrEof;

	if (iNumWords == 0 || stricmp((const char*)iWord[0], "rem")==0)

		goto NextLine;

	if (stricmp((const char*)iWord[0], "stop")==0)

		return KErrEof;

	const ObeyFileKeyword* k=0;

	for (k=iKeywords; k->iKeyword!=0; k++)

		{

		if (k->iKeywordLength == 0)

			{

			// Exact case-insensitive match on keyword

			if (stricmp((const char*)iWord[0], k->iKeyword) != 0)

				continue;

			iSuffix = 0;

			}

		else

			{

			// Prefix match

			if (strnicmp((const char*)iWord[0], k->iKeyword, k->iKeywordLength) != 0)

				continue;

			// Suffix must be empty, or a variant number in []

			iSuffix = iWord[0]+k->iKeywordLength;

			if (*iSuffix != '\0' && *iSuffix != '[')

				continue;

			}

		// found a match

		if ((k->iPass & aPass) == 0)

			goto NextLine;

		if (k->iNumArgs>=0 && (1+k->iNumArgs != iNumWords))

			{

			if(EKeywordHardwareConfigRepositoryData == k->iKeywordEnum){ // preq2131 specific 

				Print(EWarning, "Incorrect number of arguments for keyword '%s' on line %d. Extra argument(s) are ignored.\n",

				iWord[0],iCurrentLine);

				aKeyword = k->iKeywordEnum;

				return KErrNone;

			}else{

				Print(EError, "Incorrect number of arguments for keyword %s on line %d.\n",

					iWord[0], iCurrentLine);

			}

			goto NextLine;

			}

		if (k->iNumArgs<0 && (1-k->iNumArgs > iNumWords))

			{

			Print(EError, "Too few arguments for keyword %s on line %d.\n",

				iWord[0], iCurrentLine);

			goto NextLine;

			}

		aKeyword = k->iKeywordEnum;

		return KErrNone;

		}

	if (aPass == 1)

		Print(EWarning, "Unknown keyword '%s'.  Line %d ignored\n", iWord[0], iCurrentLine);

	goto NextLine;

	}

inline TBool ObeyFileReader::IsGap(char ch)

	{

	return (ch==' ' || ch=='=' || ch=='\t');

	}

TInt ObeyFileReader::Parse()

//

// splits a line into words, and returns the number of words found

//

	{

	TUint i; 

	TText *letter=iLine;

	TText *end=iLine+strlen((char *)iLine);

	for (i=0; i<KNumWords; i++)

		iWord[i]=end;

	enum TState {EInWord, EInQuotedWord, EInGap};

	TState state=EInGap;

	i=0;

	while (i<KNumWords && letter<end)

		{

		char ch=*letter;

		if (ch==0)

			break;

		if (ch=='\n')

			{

			*letter='\0';	// remove trailing newline left by fgets

			break;

			}

		switch (state)

			{

		case EInGap:

			if (ch=='\"')

				{

				if (letter[1]!=0 && letter[1]!='\"')

					iWord[i++]=letter+1;

				state=EInQuotedWord;

				}

			else if (!IsGap(ch))

				{

				iWord[i++]=letter;

				state=EInWord;

				}

			else

				*letter=0;

			break;

		case EInWord:

			if (ch=='\"')

				{

				*letter=0;

				if (letter[1]!=0 && letter[1]!='\"')

					iWord[i++]=letter+1;

				state=EInQuotedWord;

				}

			else if (IsGap(ch))

				{

				*letter=0;

				state=EInGap;

				}

			break;

		case EInQuotedWord:

			if (ch=='\"')

				{

				*letter=0;

				state=EInGap;

				}

			break;

			}

		letter++;

		}

	return i;

	}

void ObeyFileReader::ProcessLanguages(TInt64& aLanguageMask)

	{

	TInt i=1;

	while (i<iNumWords)

		{

		char *aStr=(char *)iWord[i];

		TLanguage l=ELangTest;

		if (stricmp(aStr, "test")==0)

			l=ELangTest;

		else if (stricmp(aStr, "english")==0)

			l=ELangEnglish;

		else if (stricmp(aStr, "french")==0)

			l=ELangFrench;

		else if (stricmp(aStr, "german")==0)

			l=ELangGerman;

		else if (stricmp(aStr, "spanish")==0)

			l=ELangSpanish;

		else if (stricmp(aStr, "italian")==0)

			l=ELangItalian;

		else if (stricmp(aStr, "swedish")==0)

			l=ELangSwedish;

		else if (stricmp(aStr, "danish")==0)

			l=ELangDanish;

		else if (stricmp(aStr, "norwegian")==0)

			l=ELangNorwegian;

		else if (stricmp(aStr, "finnish")==0)

			l=ELangFinnish;

		else if (stricmp(aStr, "american")==0)

			l=ELangAmerican;

		else if (stricmp(aStr, "SwissFrench")==0)

			l=ELangSwissFrench;

		else if (stricmp(aStr, "SwissGerman")==0)

			l=ELangSwissGerman;

		else if (stricmp(aStr, "Portuguese")==0)

			l=ELangPortuguese;

		else if (stricmp(aStr, "Turkish")==0)

			l=ELangTurkish;

		else if (stricmp(aStr, "Icelandic")==0)

			l=ELangIcelandic;

		else if (stricmp(aStr, "Russian")==0)

			l=ELangRussian;

		else if (stricmp(aStr, "Hungarian")==0)

			l=ELangHungarian;

		else if (stricmp(aStr, "Dutch")==0)

			l=ELangDutch;

		else if (stricmp(aStr, "BelgianFlemish")==0)

			l=ELangBelgianFlemish;

		else if (stricmp(aStr, "Australian")==0)

			l=ELangAustralian;

		else if (stricmp(aStr, "BelgianFrench")==0)

			l=ELangBelgianFrench;

		else

			{

			Print(EError, "Unknown language '%s' on line %d", iWord[i], iCurrentLine);

			exit(666);

			}

		aLanguageMask = aLanguageMask+(1<<(TInt)l);

		i++;

		}

	}

void ObeyFileReader::ProcessTime(TInt64& aTime)

//

// Process the timestamp

//

	{

	char timebuf[256];

	if (iNumWords>2)

		sprintf(timebuf, "%s_%s", iWord[1], iWord[2]);

	else

		strcpy(timebuf, (char*)iWord[1]);

	TInt r=StringToTime(aTime, timebuf);

	if (r==KErrGeneral)

		{

		Print(EError, "incorrect format for time keyword on line %d\n", iCurrentLine);

		exit(0x670);

		}

	if (r==KErrArgument)

		{