/*

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

* @internalComponent * @released

* Rofsbuild Obey file class and its reader class.

*

*/

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

	#include <sys/stat.h>

	using namespace std;

#else

	#include <strstrea.h>

	#include <iomanip.h>

#endif

#endif //__VC32__

#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 "h_utl.h"

#include "r_obey.h"

#include "r_coreimage.h"

#include "patchdataprocessor.h"

#include "filesysteminterface.h" 

#include "r_driveimage.h"

extern TInt gCodePagingOverride;

extern TInt gDataPagingOverride;

extern ECompression gCompress;

extern TBool gEnableStdPathWarning; // Default to not warn if destination path provided for a file is not in standard path.

#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[] =

{

	{_K("file"),		2,-2, EKeywordFile, "File to be copied into ROFS"},

	{_K("data"),		2,-2, EKeywordData, "same as file"},

	{_K("rofsname"),	1, 1, EKeywordRofsName, "output file for ROFS image"},

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

	{_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("rofssize"),		1, 1, EKeywordRofsSize, "maximum size of ROFS image"},

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

	{_K("version"),		1, 1, EKeywordVersion, "ROFS image version number"},

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

	{_K("extensionrofs"),1+2, 1, EKeywordExtensionRofs, "Start of definition of optional Extension ROFS"},

	{_K("extensionrofsname"),1, 1, EKeywordCoreRofsName, "ROFS image on which extension ROFS is based"},

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

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

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

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

	{_K("autosize"),	1, 1, EKeywordRofsAutoSize, "Automatically adjust maximum image size to actual used"},

	{_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("dataimagename"),1, 1,EKeywordDataImageName, "Data Drive image file name"},

	{_K("dataimagefilesystem"),1, 1,EKeywordDataImageFileSystem, "Drive image file system format"},

	{_K("dataimagesize"),1, 1,EKeywordDataImageSize, "Maximum size of Data Drive image"},

	{_K("volume"),1, -1,EKeywordDataImageVolume, "Volume Label of Data Drive image"},

	{_K("sectorsize"),1, 1,EKeywordDataImageSectorSize, "Sector size(in bytes) of Data Drive image"},

	{_K("fattable"),1, 1,EKeywordDataImageNoOfFats, "Number of FATs in the Data Drive image"},

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

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

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

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

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

	{_K("imagename"), 1, 1, EKeywordSmrImageName, "output file for SMR image"},

	{_K("hcrdata"), 1, 1, EKeywordSmrFileData, "file data for HCR SMR image"},

	{_K("formatversion"), 1, 1, EKeywordSmrFormatVersion, "format version for HCR SMR image"},

	{_K("payloadflags"), 1, 1, EKeywordSmrFlags, "payload flags for the HCR SMR image"},

	{_K("payloaduid"), 1, 1, EKeywordSmrUID, "payload UID for the HCR SMR image"},

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

};

extern TInt isNumber(TText *aString);

extern TInt getNumber(TText *aStr);

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;

	}

ObeyFileReader::ObeyFileReader(TText* aFileName):

iObeyFile(0),iMark(0), iMarkLine(0), iCurrentMark(0), iCurrentLine(0), imaxLength(0)

	{

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

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

	iNumWords = 0 ;

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

		iWord[i] = 0 ;

	iSuffix = new TText();

	iLine = 0 ;

	iCurrentObeyStatement = 0 ;

	 }

ObeyFileReader::~ObeyFileReader()

	{

	if (iObeyFile)

		fclose(iObeyFile);

	iObeyFile=0;

	delete [] iFileName;

	delete [] iLine;

	delete [] iCurrentObeyStatement;

	}

TBool ObeyFileReader::Open()

//

// Open the file & return a status

//

{

    if (!iFileName)

    {

        return EFalse;

    }

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

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

	iCurrentObeyStatement = new TText[imaxLength+1];

	strcpy((char*)iCurrentObeyStatement,(char*)iLine);

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

			{

			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

//

	{

	TInt i;

	TText *letter=iLine;

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

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

		iWord[i]=end;

	enum TState {EInWord, EInQuotedWord, EInGap};

	TState state=EInGap;

	i=0;

	while ((TUint)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::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)

		{

		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;

		TInt64 t=daysTo2000AD*24*3600+sysTime;	// seconds since 0000

		t=t+3600;								// BST (?)

		iTimeNow=t*1000000;						// milliseconds

		}

	aTime=iTimeNow;

	}

/**

Funtion to get the current oby file line

*/

TText* ObeyFileReader::GetCurrentObeyStatement() const

{ 

	return iCurrentObeyStatement;

}

// File attributes.

const FileAttributeKeyword ObeyFileReader::iAttributeKeywords[] =

{

	{"attrib",3			,0,1,EAttributeAtt, "File attributes in ROM file system"},

	{"exattrib",3		,0,1,EAttributeAttExtra, "File extra attributes in ROM file system"},

//	{_K("compress")		,1,1,EAttributeCompress, "Compress file"},

	{"stack",3			,1,1,EAttributeStack, "?"},

	{"fixed",3			,1,0,EAttributeFixed, "Relocate to a fixed address space"},

	{"priority",3		,1,1,EAttributePriority, "Override process priority"},

	{_K("uid1")			,1,1,EAttributeUid1, "Override first UID"},

	{_K("uid2")			,1,1,EAttributeUid2, "Override second UID"},

	{_K("uid3")			,1,1,EAttributeUid3, "Override third UID"},

	{_K("heapmin")		,1,1,EAttributeHeapMin, "Override initial heap size"},

	{_K("heapmax")		,1,1,EAttributeHeapMax, "Override maximum heap size"},

	{_K("capability")	,1,1,EAttributeCapability, "Override capabilities"},

	{_K("unpaged")		,1,0,EAttributeUnpaged, "Don't page code or data for this file"},

	{_K("paged")		,1,0,EAttributePaged, "Page code and data for this file"},

	{_K("unpagedcode")	,1,0,EAttributeUnpagedCode, "Don't page code for this file"},

	{_K("pagedcode")	,1,0,EAttributePagedCode, "Page code for this file"},

	{_K("unpageddata")	,1,0,EAttributeUnpagedData, "Don't page data for this file"},

	{_K("pageddata")	,1,0,EAttributePagedData, "Page data for this file"},

	{0,0,0,0,EAttributeAtt,0}

};

TInt ObeyFileReader::NextAttribute(TInt& aIndex, TInt aHasFile, enum EFileAttribute& aKeyword, TText*& aArg)

	{

NextAttribute:

	if (aIndex >= iNumWords)

		return KErrEof;

	TText* word=iWord[aIndex++];

	const FileAttributeKeyword* k;

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

		{

		if (k->iKeywordLength == 0)

			{

			// Exact match on keyword

			if (stricmp((const char*)word, k->iKeyword) != 0)

				continue;

			}

		else

			{

			// Prefix match

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

				continue;

			}

		// found a match

		if (k->iNumArgs>0)

			{

			TInt argIndex = aIndex;

			aIndex += k->iNumArgs;		// interface only really supports 1 argument

			if (aIndex>iNumWords)

				{

				Print(EError, "Missing argument for attribute %s on line %d\n", word, iCurrentLine);

				return KErrArgument;

				}