/*

* Copyright (c) 2008-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 "sisutils.h"

#include "pkgfileparser.h"

// Parse options lookups

#define MAXTOKENLEN	30

struct SParseToken

{

	WCHAR pszOpt[MAXTOKENLEN];

	DWORD dwOpt;

};

const SParseToken KTokens[] =

{

	{L"if",		IF_TOKEN},

	{L"elseif",	ELSEIF_TOKEN},

	{L"else",	ELSE_TOKEN},

	{L"endif",	ENDIF_TOKEN},

	{L"exists",	EXISTS_TOKEN},

	{L"devprop",DEVCAP_TOKEN},

	{L"appcap",	APPCAP_TOKEN},

	{L"package",DEVCAP_TOKEN},

	{L"appprop",APPCAP_TOKEN},

	{L"not",	NOT_TOKEN},

	{L"and",	AND_TOKEN},

	{L"or",		OR_TOKEN},

	{L"type",	TYPE_TOKEN},

	{L"key",	KEY_TOKEN},

};

#define NUMPARSETOKENS (sizeof(KTokens)/sizeof(SParseToken))

/**

Constructor: PkgParser class

Initilize the parameters to data members.

@internalComponent

@released

@param aFile	- Name of the package script file

*/

PkgParser::PkgParser(String aFile) : iPkgFile(aFile), m_nLineNo(0)

{

}

/**

Destructor: PkgParser class

Deallocates the memory for data members

@internalComponent

@released

*/

PkgParser::~PkgParser()

{

	if(iPkgHandle != INVALID_HANDLE_VALUE)

	{

		::CloseHandle(iPkgHandle);

	}

	DeleteAll();

}

/**

OpenFile: Opens the package script file

@internalComponent

@released

*/

int PkgParser::OpenFile()

{

	iPkgHandle = ::CreateFileW(string2wstring(iPkgFile).data(),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);

	return (iPkgHandle != INVALID_HANDLE_VALUE) ? 1 : 0;

}

/**

GetEmbeddedSisList: Returns the embedded sis file list

@internalComponent

@released

@param embedSisList	- reference to sis file list structure

*/

void PkgParser::GetEmbeddedSisList(SISFILE_LIST& embedSisList)

{

	embedSisList = iEmbedSisFiles;

}

/**

GetInstallOptions: Returns the install options read from the package file

@internalComponent

@released

@param aOptions	- reference to the string list structure

*/

void PkgParser::GetInstallOptions(FILE_LIST& aOptions)

{

	aOptions = iInstallOptions;

}

/**

GetLanguageList: Returns the language list read from the package file

@internalComponent

@released

@param langList	- reference to the language list structure

*/

void PkgParser::GetLanguageList(LANGUAGE_LIST& langList)

{

	langList = iLangList;

}

/**

GetHeader: Returns the header details read from the package file

@internalComponent

@released

@param pkgHeader	- reference to the package header structure

*/

void PkgParser::GetHeader(PKG_HEADER& pkgHeader)

{

	pkgHeader = iPkgHeader;

}

/**

GetCommandList: Returns the package body details read from the package file

@internalComponent

@released

@param cmdList	- reference to the command list structure

*/

void PkgParser::GetCommandList(CMDBLOCK_LIST& cmdList)

{

	cmdList = iPkgBlock;

}

/**

ParsePkgFile: Parses the package file

@internalComponent

@released

*/

void PkgParser::ParsePkgFile()

{

	if(!OpenFile())

	{

		throw SisUtilsException((char*)iPkgFile.data(), "Could not open file");

	}

	GetNextChar();

	// skip unicode marker if present

	if(m_pkgChar==0xFEFF) GetNextChar();

	GetNextToken ();

	while(m_token!=EOF_TOKEN)

	{

		ParseEmbeddedBlockL();

		switch (m_token)

		{

		case '&':

			GetNextToken ();

			ParseLanguagesL();

			break;

		case '#':

			GetNextToken ();

			ParseHeaderL();

			break;

		case '%':

			GetNextToken ();

			ParseVendorNameL();

			break;

		case '=':

			GetNextToken ();

			ParseLogoL();

			break;

		case '(':

			GetNextToken ();

			ParseDependencyL();

			break;

		case ':':

			GetNextToken ();

			ParseVendorUniqueNameL();

			break;

		case '[':

			GetNextToken ();

			ParseTargetDeviceL();

			break;

		case EOF_TOKEN:

			break;

		default:

			ParserError("Unexpected token");

			break;

		}

	}

}

/**

ParseLanguagesL: Parses the language section

@internalComponent

@released

*/

void PkgParser::ParseLanguagesL()

{

	unsigned long langCode = 0;

	unsigned long dialect = 0;

	while (true)

	{

		if (m_token==ALPHA_TOKEN)

		{

			langCode = PkgLanguage::GetLanguageCode(m_tokenValue.pszString);

		}

		else if (m_token==NUMERIC_TOKEN && m_tokenValue.dwNumber>=0 && m_tokenValue.dwNumber<=1000)

		{

			langCode = (m_tokenValue.dwNumber);

		}

		GetNextToken ();

		// Check if a dialect is defined

		if (m_token == '(')

		{

			GetNumericToken();

			// Modify the last added language code, combining it with dialect code

			dialect = (m_tokenValue.dwNumber);

			GetNextToken ();

			GetNextToken ();

		}

		AddLanguage(wstring2string(PkgLanguage::GetLanguageName(langCode)), langCode, dialect);

		if (m_token!=',')

			return;

		GetNextToken ();

	}

}

/**

ParseHeaderL: Parses the package header section

@internalComponent

@released

*/

void PkgParser::ParseHeaderL()

{

	if (!iLangList.size())

	{

		//No languages defined, assuming English."

		AddLanguage("EN", PkgLanguage::ELangEnglish, 0);

	}

	// process application names

	ExpectToken('{');

	for (WORD wNumLangs = 0; wNumLangs < iLangList.size(); wNumLangs++)

	{

		GetNextToken ();

		ExpectToken(QUOTED_STRING_TOKEN);

		iPkgHeader.pkgNameList.push_back(wstring2string(m_tokenValue.pszString));

		GetNextToken ();

		if (wNumLangs < (iLangList.size()-1) )

		{

			ExpectToken(',');

		}

	}

	ExpectToken('}');

	GetNextToken (); 

	ExpectToken(',');

	GetNextToken ();

	ExpectToken('(');

	GetNextToken ();

	ExpectToken(NUMERIC_TOKEN);

	iPkgHeader.pkgUid = m_tokenValue.dwNumber;

	GetNextToken ();

	ExpectToken(')');

	GetNextToken ();

	ExpectToken(',');

	GetNextToken ();

	ExpectToken(NUMERIC_TOKEN);

	iPkgHeader.vMajor = m_tokenValue.dwNumber;

	GetNextToken ();

	ExpectToken(',');

	GetNextToken ();

	ExpectToken(NUMERIC_TOKEN);

	iPkgHeader.vMinor = m_tokenValue.dwNumber;

	GetNextToken ();

	ExpectToken(',');

	GetNextToken ();

	ExpectToken(NUMERIC_TOKEN);

	iPkgHeader.vBuild = m_tokenValue.dwNumber;

	GetNextToken ();

	// Parse any options

	while (m_token==',')

	{

		GetNextToken ();

		if (m_token==TYPE_TOKEN)

		{

			GetNextToken ();

			ExpectToken('=');

			GetNextToken ();

			iPkgHeader.pkgType = wstring2string(m_tokenValue.pszString);

			GetNextToken ();

		}

		else

			GetNextToken ();

	}

}

/**

ParseEmbeddedBlockL: Parses the package body block

@internalComponent

@released

*/

void PkgParser::ParseEmbeddedBlockL ()

{

	while(m_token!=EOF_TOKEN)

	{

		switch (m_token)

		{

		case QUOTED_STRING_TOKEN:

			ParseFileL ();

			break;

		case '@':

			GetNextToken ();

			ParsePackageL ();

			break;

		case '!':

			GetNextToken ();

			ParseOptionsBlockL();

			break;

		case '+':

			GetNextToken ();

			ParsePropertyL ();

			break;

		case IF_TOKEN:

			GetNextToken ();

			ParseIfBlockL ();

			break;

		case ';' :

			ParseCommentL ();

			break;

		default :

			return;

		}

	}

}

/**

ParseFileL: Parses the file list section

@internalComponent

@released

*/

void PkgParser::ParseFileL()

{

	PCMD_BLOCK pCmdBlock = 0;

	PINSTALLFILE_LIST pFileList = 0;

	std::wstring sourceFile (m_tokenValue.pszString);

	// Linux and windows both support forward slashes so if source path is given '\' need to convert

	// in forward slash for compatibility.

	wchar_t *pBuffer = (wchar_t*)sourceFile.c_str();

	wchar_t *pCurrent = pBuffer;

	while (pBuffer && *pBuffer && (pCurrent = wcschr(pBuffer,L'\\')) != NULL)

	{

		*pCurrent = L'/';

		pBuffer = pCurrent + 1;

	}

	GetNextToken ();

	ExpectToken('-');

	GetNextToken ();

	ExpectToken(QUOTED_STRING_TOKEN);

	std::wstring destinationFile (m_tokenValue.pszString);

	// SWI only supports backward slashesh so need to convert destination path in backward slash if

	// user gives '/' in Linux.

	pBuffer = (wchar_t*)destinationFile.c_str();

	pCurrent = pBuffer;

	while (pBuffer && *pBuffer && (pCurrent = wcschr(pBuffer,L'/')) != NULL)

	{

		*pCurrent = L'\\';

		pBuffer = pCurrent + 1;

	}

	GetNextToken ();

	// Test for options

	if (m_token!=',')

	{

		pCmdBlock = new CMD_BLOCK;

		pFileList = new INSTALLFILE_LIST;

		pCmdBlock->cmdType = INSTALLFILE;

		pCmdBlock->iInstallFileList = pFileList;

		pFileList->langDepFlg = 0;

		pFileList->srcFiles.push_back(wstring2string(sourceFile));

		pFileList->destFile = wstring2string(destinationFile);

		iPkgBlock.push_back(pCmdBlock);

	}

	else

	{	

		bool needAdd = false;

		while(m_token==',')

		{

			GetNextToken ();

			std::wstring installOption = m_tokenValue.pszString;

			if((installOption == L"FF") || (installOption == L"FILE"))

			{

				needAdd = true;

			}

			GetNextToken ();

		}

		if (needAdd)

		{

			pCmdBlock = new CMD_BLOCK;

			pFileList = new INSTALLFILE_LIST;

			pCmdBlock->cmdType = INSTALLFILE;

			pCmdBlock->iInstallFileList = pFileList;

			pFileList->langDepFlg = 0;

			pFileList->srcFiles.push_back(wstring2string(sourceFile));

			pFileList->destFile = wstring2string(destinationFile);

			iPkgBlock.push_back(pCmdBlock);

		}

	}

}

/**

ParseIfBlockL: Parses the conditional installation body

@internalComponent

@released

*/

void PkgParser::ParseIfBlockL()

{

	PCMD_BLOCK pCmdBlock = 0; 

	//IF

	pCmdBlock = new CMD_BLOCK;

	pCmdBlock->cmdType = IF;

	ParseLogicalOp(pCmdBlock->cmdExpression);

	iPkgBlock.push_back(pCmdBlock);

	ParseEmbeddedBlockL ();

	while (m_token==ELSEIF_TOKEN)

	{

		GetNextToken ();

		//ELSEIF

		pCmdBlock = new CMD_BLOCK;

		pCmdBlock->cmdType = ELSEIF;

		ParseLogicalOp(pCmdBlock->cmdExpression);

		iPkgBlock.push_back(pCmdBlock);

		ParseEmbeddedBlockL ();

	}

	if (m_token==ELSE_TOKEN)

	{

		GetNextToken ();

		//ELSEIF

		pCmdBlock = new CMD_BLOCK;

		pCmdBlock->cmdType = ELSE;

		iPkgBlock.push_back(pCmdBlock);

		ParseEmbeddedBlockL ();

	}

	ExpectToken(ENDIF_TOKEN);

	//ENDIF

	pCmdBlock = new CMD_BLOCK;

	pCmdBlock->cmdType = ENDIF;

	iPkgBlock.push_back(pCmdBlock);

	GetNextToken ();

}

/**

ParseLogicalOp: Parses the logical expression

@internalComponent

@released

*/

void PkgParser::ParseLogicalOp (String& aExpression)

{

    ParseRelation (aExpression);

	switch (m_token)

	{

	case AND_TOKEN:

	case OR_TOKEN: