/*

* 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>

#include <strstream>

#include <iomanip>

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <assert.h>

#include <errno.h>

#include <e32std.h>

#include <e32std_private.h>

#include <e32rom.h>

#include <u32std.h>

#include <f32file.h>

#include "r_rom.h"

#include "r_obey.h"

#include "r_global.h"

#include "h_utl.h"

#include "patchdataprocessor.h"

#include "r_coreimage.h" 

#include "uniconv.hpp"

extern TBool gIsOBYUTF8;

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

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

static char* const NullString = "" ;

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;

//

// Constructor

//

ObeyFileReader::ObeyFileReader(const char* aFileName):iFileName(aFileName),iCurrentLine(0), iNumWords(0),iLine(0),iMarkLine(0)  {

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

		iWord[i] = NullString ;	 

	*iSuffix = 0 ; 

}

ObeyFileReader::~ObeyFileReader() {

	if(iLine)

		delete [] iLine;

}

//

// Open the file & return a status

//

TBool ObeyFileReader::Open() {

	ifstream ifs(iFileName.c_str(),ios_base::in + ios_base::binary);

	if (!ifs.is_open()) {

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

		return EFalse;

	}

	iLines.clear();

	if(iLine){

		delete []iLine;

		iLine = 0 ;

	}		

	ifs.seekg(0,ios_base::end);

	size_t length = ifs.tellg();

	char* buffer = new char[length + 2];

	if (0 == buffer) {

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

		return EFalse;

	}

	ifs.seekg(0,ios_base::beg);

	ifs.read(buffer,length); 

	size_t readcout = ifs.gcount() ;

	if(readcout != length){ 	

		Print(EError,"Cannot Read All of File.");	

		delete []buffer ;

		ifs.close();

		return EFalse;

	}

	buffer[length] = '\n';

	buffer[length + 1] = 0 ; 

	ifs.close();

	char* lineStart = buffer ;

	char* end = buffer + length ;

	string line ;

	size_t maxLengthOfLine = 0 ; 

	while(lineStart <= end){

		while(*lineStart == ' ' || *lineStart == '\t') //trimleft 

			lineStart ++ ;		

		char* lineEnd = lineStart ;	 

		while(*lineEnd != '\r' && *lineEnd != '\n')

			lineEnd ++ ;

		if(strnicmp(lineStart,"REM",3) == 0){

			line = "" ; // REMOVE "REM ... "

		}

		else {

			TInt lastIndex = lineEnd - lineStart - 1;

			while(lastIndex >= 0 &&  // trimright

				(lineStart[lastIndex] == ' ' || lineStart[lastIndex] == '\t'))

				lastIndex -- ;

			if(lastIndex >= 0)

				line.assign(lineStart,lastIndex + 1);

			else

				line = "";

		}

		if(line.length() > maxLengthOfLine)

			maxLengthOfLine = line.length();

		iLines.push_back(line);

		if(*lineEnd == '\r') {

			if(lineEnd[1] == '\n')

				lineStart = lineEnd + 2 ;

			else

				lineStart = lineEnd + 1 ;

		}

		else // '\n'

			lineStart = lineEnd + 1 ; 

	}	

	delete []buffer ;

	iLine = new char[maxLengthOfLine + 1]; 

	iCurrentLine = 0 ;

	iMarkLine = 0 ;

	return ETrue;

}

void ObeyFileReader::Mark()	{ 

	iMarkLine = iCurrentLine - 1;

}

void ObeyFileReader::MarkNext() { 

	iMarkLine = iCurrentLine;

}

void ObeyFileReader::Rewind() {

	iCurrentLine = iMarkLine;

}

char* ObeyFileReader::DupWord(TInt aIndex) const {

	char* retVal = 0 ;

	if(aIndex >= 0 && aIndex < (TInt)KNumWords){

		size_t len = strlen(iWord[aIndex]) + 1;

		retVal = new char[len];

		if(retVal)

			memcpy(retVal,iWord[aIndex],len);

	} 

	return retVal ;

}

TInt ObeyFileReader::ReadAndParseLine() {

	if (iCurrentLine >= (TInt)iLines.size())

		return KErrEof;

	iCurrentLine++; 

	iNumWords = Parse();

	return KErrNone;

}

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

	{

NextLine:

	TInt err = ReadAndParseLine();

	if (err == KErrEof)

		return KErrEof;

	if (iNumWords == 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 []

			strncpy(iSuffix,iWord[0]+k->iKeywordLength,80);

			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;

}

//

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

// 

TInt ObeyFileReader::Parse() {

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

		iWord[i] = NullString;

	enum TState {EInWord, EInQuotedWord, EInGap};

	TState state = EInGap;	 

	TUint i = 0;

	const string& line = iLines[iCurrentLine -1];  

	memcpy(iLine,line.c_str(),line.length());

	iLine[line.length()] = 0 ; 

	char* linestr = iLine;

	while (i < KNumWords && *linestr != 0) {

		switch (state) {

		case EInGap:

			if (*linestr =='\"') {

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

					iWord[i++] = linestr + 1;

				state = EInQuotedWord;

			}

			else if (!IsGap(*linestr)) {

				iWord[i++] = linestr;

				state=EInWord;

			}

			else

				*linestr=0;

			break;

		case EInWord:

			if (*linestr == '\"') {

				*linestr = 0;

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

					iWord[i++] = linestr+1;

				state=EInQuotedWord;

			}

			else if (IsGap(*linestr)) {

				*linestr=0;

				state=EInGap;

			}

			break;

		case EInQuotedWord:

			if (*linestr == '\"'){

				*linestr = 0;

				state = EInGap;

			}

			break;

		}

		linestr++;

	}

	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++;

	}

}

//

// Process the timestamp

//

void ObeyFileReader::ProcessTime(TInt64& aTime) {

	char timebuf[256];

	if (iNumWords>2)

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

	else

		strncpy(timebuf, iWord[1],256);

	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) {

		Print(EError, "Time out of range on line %d\n", iCurrentLine);

		exit(0x670);

	}

}

TInt64 ObeyFileReader::iTimeNow=0;

void ObeyFileReader::TimeNow(TInt64& aTime) {

	if (iTimeNow==0) {

		TInt sysTime=time(0);					// seconds since midnight Jan 1st, 1970

		sysTime-=(30*365*24*60*60+7*24*60*60);	// seconds since midnight Jan 1st, 2000

		TInt64 daysTo2000AD=730497;