/*

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

#include "localise.h"

#ifdef __VC32__ 

#pragma warning( push, 1 )	// MS STL libraries do not compile cleanly, temporarily set warning level to 1

#pragma warning( disable : 4710 )	// function not inlined.

#pragma warning( disable : 4530 )	// function not inlined.

#endif

#include <cstdio>

#include <iostream>

#include "ERRORHAN.H"

#include <cstring>

#include <cstdlib>

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

using std::ifstream;

using std::cerr;

using std::endl;

#endif //__MSVCDOTNET__

/******************************************************************************************

**

** RlsItemRequirements

**

******************************************************************************************/

RlsItemRequirements::RlsItemRequirements(String aRlsName, int aRequirement)

	:iRlsName(aRlsName),

	iRequirement(aRequirement)

	{}

RlsItemRequirements::RlsItemRequirements(const RlsItemRequirements & aRlsItemRequirements)

	:iRlsName(aRlsItemRequirements.iRlsName),

	iRequirement(aRlsItemRequirements.iRequirement)

	{}

RlsItemRequirements::~RlsItemRequirements() 

	{}

/******************************************************************************************

**

** CommandRequirementsHolder

**

******************************************************************************************/

CommandRequirementsHolder::CommandRequirementsHolder(String aCommandName)

	:iCommandName(aCommandName)

	{

	iRlsRequirements.clear();

	}

CommandRequirementsHolder::CommandRequirementsHolder(const CommandRequirementsHolder & aCommandRequirmentsHolder)

	:iCommandName(aCommandRequirmentsHolder.iCommandName)

	{

	for(unsigned int j = 0; j < aCommandRequirmentsHolder.iRlsRequirements.size() ; j++)

		{

		iRlsRequirements.push_back(aCommandRequirmentsHolder.iRlsRequirements[j]);

		}

	}

CommandRequirementsHolder::~CommandRequirementsHolder()

	{}

/******************************************************************************************

**

** TagParameterData

**

******************************************************************************************/

TagParameterData::TagParameterData(String aTagParameter)

	:iTagParameter(aTagParameter)

	{}

TagParameterData::TagParameterData(const TagParameterData & aTagParameterData)

	:iTagParameter(aTagParameterData.iTagParameter)

	{}

TagParameterData::~TagParameterData()

	{}

void TagParameterData::SetTagParameter(String aTagParameter)

	{

	iTagParameter = aTagParameter;

	}

String TagParameterData::GetTagParameter()

	{

	return iTagParameter;

	}

/******************************************************************************************

**

** CommentRequirement

**

******************************************************************************************/

CommentRequirement::CommentRequirement(int aRequirementStatus, String aDefaultParameter)

	:iRequirementStatus(aRequirementStatus),

	iDefaultParameter(aDefaultParameter)

	{

	}

CommentRequirement::CommentRequirement(const CommentRequirement & aCommentRequirement)

	:iRequirementStatus(aCommentRequirement.iRequirementStatus),

	iDefaultParameter(aCommentRequirement.iDefaultParameter)

	{

	}

CommentRequirement::~CommentRequirement()

	{}

String CommentRequirement::GetDefault()

	{

	return iDefaultParameter;

	}

int CommentRequirement::GetRequirementStatus()

	{

	return iRequirementStatus;

	}

/******************************************************************************************

**

** CommentRequirementPair

**

******************************************************************************************/

CommentRequirementPair::CommentRequirementPair(String aRlsItem, int aStatus, String aDefault)

	:iRlsItem(aRlsItem),

	iCommentRequirementData(aStatus, aDefault)

	{

	}

CommentRequirementPair::CommentRequirementPair(const CommentRequirementPair & aCommentRequirementPair)

	:iRlsItem(aCommentRequirementPair.iRlsItem),

	iCommentRequirementData(aCommentRequirementPair.iCommentRequirementData)

	{}

CommentRequirementPair::~CommentRequirementPair()

	{}

int CommentRequirementPair::GetRequirementStatus()

	{

	return iCommentRequirementData.GetRequirementStatus();

	}

String CommentRequirementPair::CheckIfOptionalAndHasDefault(String aRlsTypeName, String aCommandName)

	{ // returns a String containing a line which needs to be written out to the rpp file, or returns ""

	String optionalLineToAdd = "";

	if(iRlsItem == aRlsTypeName)

		{

		int requirementStatus = iCommentRequirementData.GetRequirementStatus();

		if(requirementStatus == EOptionalWithDefault)

			{

			String defaultValue = iCommentRequirementData.GetDefault();

			if(defaultValue.Length()) // will only return true if a default exists

				{

				optionalLineToAdd = "@";

				optionalLineToAdd += aCommandName;

				String tempString(" ");

				optionalLineToAdd += tempString;

				optionalLineToAdd += defaultValue;

				tempString = "\n";

				optionalLineToAdd += tempString;

				}

			}

		}

	return optionalLineToAdd;

	}

String CommentRequirementPair::GetRlsItem()

	{

	return iRlsItem;

	}

void CommentRequirementPair::SetRlsItem(String aRlsItem)

	{

	iRlsItem = aRlsItem;

	}

/******************************************************************************************

**

** CommentTag

**

******************************************************************************************/

CommentTag::CommentTag(String aTagType, bool aTagDeclared)

	:iTagDeclared( aTagDeclared ),

	iParameterType( aTagType )

	{

	iPermissibleParameters.clear();

	iRequirements.clear();

	}

CommentTag::CommentTag(const CommentTag & aCommentTag)

	:iTagDeclared( aCommentTag.iTagDeclared ),

	iParameterType( aCommentTag.iParameterType )

	{

	unsigned int j;

	for(j=0; j< aCommentTag.iPermissibleParameters.size(); j++)

		{

		iPermissibleParameters.push_back(aCommentTag.iPermissibleParameters[j]);

		}

	for(j=0; j< aCommentTag.iRequirements.size(); j++)

		{

		iRequirements.push_back(aCommentTag.iRequirements[j]);

		}

	}		

CommentTag::~CommentTag()

	{}

String CommentTag::CheckIfOptionalAndHasDefault(String aRlsTypeName, String aCommandName)

	{

	if(iTagDeclared)

		{

		for(unsigned int j=0; j<iRequirements.size(); j++)

			{

			String defaultParameter = iRequirements[j].CheckIfOptionalAndHasDefault(aRlsTypeName, aCommandName);

			if(defaultParameter.Length())

				return defaultParameter; // returns default parameter if it exists

			}

		}

	return ""; // returns "" if no default parameter exists

	}

int CommentTag::GetRequirementStatus(String aRlsItem)

	{

	for(unsigned int j=0; j<iRequirements.size(); j++)

		{

		if(iRequirements[j].GetRlsItem() == aRlsItem)

			{

			int requirementStatus = iRequirements[j].GetRequirementStatus();

			return requirementStatus;

			}

		}

	return EForbidden;

	}

bool CommentTag::IsTagLegalForRlsType(String aRlsTypeName)

	{

	for(unsigned int j=0; j<iRequirements.size(); j++)

		{

		if(iRequirements[j].GetRlsItem() == aRlsTypeName)

			{

			return iRequirements[j].GetRequirementStatus() != EForbidden ? true : false; 

			}

		}

	return false;

	}

bool CommentTag::IsParameterAlreadyDeclared(String aTagParameter)

	{

	for(int j=0; j<GetNumberOfPermissibleParameters(); j++)

		{

		if(iPermissibleParameters[j].GetTagParameter() == aTagParameter)

			{

			return true; // returns true if the given parameter is already declared

			}

		}

	return false;

	}

String CommentTag::GetPermissibleParameter(int aIndex) // returns pointer to aIndex-th parameter

	{

	return iPermissibleParameters[aIndex].GetTagParameter();

	}

int CommentTag::GetNumberOfPermissibleParameters()

	{

	return iPermissibleParameters.size();

	}

bool CommentTag::IsTagDeclared()

	{

	return iTagDeclared;

	}

void CommentTag::SetDeclared()

	{

	iTagDeclared = true;

	}

void CommentTag::SetParameterType(String aParameterType)

	{

	iParameterType = aParameterType;

	}

String CommentTag::GetParameterType()

	{

	return iParameterType;

	}

void CommentTag::AddTagParameterData(String aTagParameterData)

	{

	TagParameterData dataToAdd( aTagParameterData );

	iPermissibleParameters.push_back( dataToAdd );

	}

void CommentTag::AddRequirements(String aRlsItem, int aRequired, String aDefault)

	{

	CommentRequirementPair commentRequirementPair( aRlsItem, aRequired, aDefault );

	iRequirements.push_back( commentRequirementPair );

	}

/******************************************************************************************

**

** CommentTag

**

******************************************************************************************/

CommentTagPair::CommentTagPair(String aCommandName, String aParameterType, bool aTagDeclared)

	:iCommandName(aCommandName),

	iTagVariables(aParameterType, aTagDeclared)

	{}

CommentTagPair::CommentTagPair(const CommentTagPair & aCommentTagPair)

	:iCommandName(aCommentTagPair.iCommandName),

	iTagVariables(aCommentTagPair.iTagVariables)

	{}

CommentTagPair::~CommentTagPair()

	{}

String CommentTagPair::CheckIfOptionalAndHasDefault(String aRlsTypeName)

	{

	return iTagVariables.CheckIfOptionalAndHasDefault(aRlsTypeName, iCommandName);

	}

int CommentTagPair::GetRequirementStatus(String aRlsItem)

	{

	return iTagVariables.GetRequirementStatus( aRlsItem );

	}

bool CommentTagPair::IsTagLegalForRlsType(String aRlsTypeName)

	{

	return iTagVariables.IsTagLegalForRlsType(aRlsTypeName);

	}

bool CommentTagPair::IsParameterAlreadyDeclared(String aTagParameter)

	{

	return iTagVariables.IsParameterAlreadyDeclared(aTagParameter);

	}

String CommentTagPair::GetPermissibleParameter(int aIndex)

	{

	return iTagVariables.GetPermissibleParameter(aIndex);

	}

int CommentTagPair::GetNumberOfPermissibleParameters()

	{

	return iTagVariables.GetNumberOfPermissibleParameters();

	}

void CommentTagPair::SetCommandName(String aCommandName)

	{

	iCommandName = aCommandName;

	}

String CommentTagPair::GetCommandName()

	{

	return iCommandName;

	}

void CommentTagPair::SetTagDeclared()

	{

	iTagVariables.SetDeclared();

	}

bool CommentTagPair::TagDeclared()

	{

	return iTagVariables.IsTagDeclared();

	}

String CommentTagPair::GetParameterType()

	{

	return iTagVariables.GetParameterType();

	}

void CommentTagPair::AddPermissibleParameter(String aPermissibleParameter)

	{

	iTagVariables.AddTagParameterData( aPermissibleParameter );

	}

void CommentTagPair::AddRlsItem(String aRlsItem, int aRequired, String aDefault)

	{

	iTagVariables.AddRequirements(aRlsItem, aRequired, aDefault);

	}

/******************************************************************************************

**

** LocalisationLine

**

******************************************************************************************/

LocalisationLine::LocalisationLine(String aFileName, int aFirstLine)

	:iAnalysed(false),

	iFirstLine(aFirstLine),

	iLastLine(aFirstLine),

	iFileName(aFileName)

	{

	iData.clear();

	}

LocalisationLine::LocalisationLine(const LocalisationLine & aLocalisationLine)

	:iAnalysed(aLocalisationLine.iAnalysed),

	iFirstLine(aLocalisationLine.iFirstLine),

	iLastLine(aLocalisationLine.iLastLine),

	iFileName(aLocalisationLine.iFileName)	

	{

	for(unsigned int j=0; j<aLocalisationLine.iData.size(); j++)

		{

		iData.push_back(aLocalisationLine.iData[j]);

		}

	}

LocalisationLine::~LocalisationLine()

	{}

void LocalisationLine::Reset(String aFileName, int aFirstLine)

	{

	iFirstLine = aFirstLine;

	iLastLine = aFirstLine;

	iFileName = aFileName;

	iAnalysed = false;

	iData.clear();

	}

String LocalisationLine::GetFileName()

	{

	return iFileName;

	}

int LocalisationLine::GetFirstLine()

	{

	return iFirstLine;

	}

int LocalisationLine::GetLastLine()

	{

	return iLastLine;

	}

void LocalisationLine::SetFirstLine(int aFirstLine)

	{

	iFirstLine = aFirstLine;

	}

void LocalisationLine::SetFileName(String aFileName)

	{

	iFileName = aFileName;

	}

unsigned int LocalisationLine::GetNumberOfTokens()

	{

	return iData.size();

	}

String LocalisationLine::GetElement(unsigned int aIndex)

	{

	return iData[aIndex];

	}

void LocalisationLine::AddElement(String aElement)

	{

	iData.push_back(aElement);

	}

void LocalisationLine::SetLastLine(int aLastLine)

	{

	iLastLine = aLastLine;

	}

void LocalisationLine::SetAnalysed(bool aParity)

	{

	iAnalysed = aParity;

	}

void LocalisationLine::Empty()

	{

	iData.clear();

	}

bool LocalisationLine::IsLineAnalysed()

	{

	return iAnalysed;

	}

/******************************************************************************************

**

** LocalisationComment

**

******************************************************************************************/

LocalisationComment::LocalisationComment(LocalisationLine & aComment)

	:iOriginalData(aComment)

	{

	iData.clear();

	iOptionalLinesToAdd.clear();

	}

LocalisationComment::~LocalisationComment()

	{