/*
* 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 <stdio.h>   
#include <iostream>
#include "ERRORHAN.H"

#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()
	{
	}

String LocalisationComment::GetFileName()
	{
	return iOriginalData.GetFileName();
	}

int LocalisationComment::GetFirstLineOfComment()
	{
	return iOriginalData.GetFirstLine();
	}

int LocalisationComment::GetLastLineOfComment()
	{
	return iOriginalData.GetLastLine();
	}

int LocalisationComment::GetNumberOfOptionalLinesToAdd()
	{
	return iOptionalLinesToAdd.size();
	}

unsigned int LocalisationComment::GetNumberOfTokensInComment()
	{
	return iOriginalData.GetNumberOfTokens();
	}

String LocalisationComment::GetOriginalElement(unsigned int aIndex)
	{
	return iOriginalData.GetElement(aIndex);
	}

void LocalisationComment::AddDataLine(LocalisationLine aDataLine)
	{
	iData.push_back( aDataLine );
	}

unsigned int LocalisationComment::GetNumberOfTokensInLine(unsigned int aIndex)
	{
	return iData[aIndex].GetNumberOfTokens();
	}

LocalisationLine LocalisationComment::GetLine(unsigned int aIndex)
	{
	return iData[aIndex];
	}

void LocalisationComment::SetAnalysed(unsigned int aIndex, bool aParity)
	{
	iData[aIndex].SetAnalysed(aParity);
	}

void LocalisationComment::SetLastLine(int aLineNumber)
	{
	iOriginalData.SetLastLine(aLineNumber);
	}

bool LocalisationComment::IsLineAnalysed(unsigned int aIndex)
	{
	return iData[aIndex].IsLineAnalysed();
	}

void LocalisationComment::SetWholeTagAnalysed(bool aParity)
	{
	iOriginalData.SetAnalysed(aParity);
	}

String LocalisationComment::GetElementFromLine(unsigned int aLine, unsigned int aElement)
	{
	return iData[aLine].GetElement(aElement);
	}

int LocalisationComment::GetFirstLine(unsigned int aIndex)
	{
	return iData[aIndex].GetFirstLine();
	}

void LocalisationComment::AddOptionalData(String aOptionalData)
	{
	iOptionalLinesToAdd.push_back(aOptionalData);
	}

String LocalisationComment::GetOptionalLineToAdd(unsigned int aLine)
	{
	return iOptionalLinesToAdd[aLine];
	}

unsigned int LocalisationComment::GetNumberOfLinesInComment()
	{
	return iData.size();
	}

/******************************************************************************************
**
** WarningToOutput
**
******************************************************************************************/

WarningToOutput::WarningToOutput(const String aFileName, int aLineNumber, String aComment)
	:iFileName(aFileName),
	iLineNumber(aLineNumber),
	iComment(aComment)
	{}

WarningToOutput::WarningToOutput(const WarningToOutput & aWarningToOutput)
	:iFileName(aWarningToOutput.iFileName),
	iLineNumber(aWarningToOutput.iLineNumber),
	iComment(aWarningToOutput.iComment)
	{}
	
WarningToOutput::~WarningToOutput()
	{}

const String WarningToOutput::GetFileName()
	{
	return iFileName;
	}

int WarningToOutput::GetLineNumber()
	{
	return iLineNumber;
	}

String WarningToOutput::GetComment()
	{
	return iComment;
	}

WarningToOutput& WarningToOutput::operator=(const WarningToOutput& aWarningToOutput)
	{
	if(&aWarningToOutput==this)
		return *this;
	iFileName = aWarningToOutput.iFileName;
	iLineNumber = aWarningToOutput.iLineNumber;
	iComment = aWarningToOutput.iComment;
	return *this;
	}

/******************************************************************************************
**
** GlobalLocalisationData
**
******************************************************************************************/

GlobalLocalisationData::GlobalLocalisationData() 
	:iCommentStarted(true)
	{
	iTypes[0] = "single";
	iTypes[1] = "multiple";
	iTypes[2] = "void";
	iTypes[3] = "text";
	iRlsTypes[0] = "rls_string";
	iRlsTypes[1] = "rls_string8";
	iRlsTypes[2] = "rls_byte";
	iRlsTypes[3] = "rls_word";
	iRlsTypes[4] = "rls_long";
	iRlsTypes[5] = "rls_double";
	iRlsTypes[6] = "RESOURCE";
	iCommentTagStore.clear();
	iCommentDefinitions.clear();
	iWarningStore.clear();
	}

GlobalLocalisationData::~GlobalLocalisationData() 
	{
	}
	
int GlobalLocalisationData::NeedToAddDefaultData(String aFileName, int aFileLine)
	{
	for(unsigned int j=0; j<iCommentTagStore.size(); j++)
		{
		String fileName = iCommentTagStore[j].GetFileName();
		if(fileName == aFileName)
			{
			int lastLine = iCommentTagStore[j].GetLastLineOfComment();
			if(lastLine == aFileLine)
				{
				if(iCommentTagStore[j].GetNumberOfOptionalLinesToAdd())
					return j; // returns the index of the localisation comment which needs default data adding
				else
					return -1; // if default data doesn't need adding for this rls item then returns -1
				}
			}
		}
	return -1;
	}

void GlobalLocalisationData::AddCommentToStore()
	{
	LocalisationComment aLocalisationComment( iTempCommentStore );
	iCommentTagStore.push_back(aLocalisationComment);
	}

void GlobalLocalisationData::SetStart(String aFileName, int aLineNumber)
	{
	if(iCommentStarted == false) //means that any time other than first time, contents will be added to Store
		{
		AddCommentToStore();
		iTempCommentStore.Reset(aFileName, aLineNumber); // empties the temporary comment store
		}
	else
		{
		iTempCommentStore.SetFirstLine( aLineNumber );
		iTempCommentStore.SetFileName( aFileName );
		}
	iCommentStarted = false;
	}

void GlobalLocalisationData::AnalyseLocalisationData()
	{
	for(unsigned int i = 0; i < iCommentTagStore.size(); i++)
		{
		ParseCommentTags(i);
		}
	CheckIfCommentTagsFullyAnalysed();
	CheckRlsEntries();
	}

void GlobalLocalisationData::ParseCommentTags(unsigned int i)
	{
	LocalisationLine tagCommandLine;
	int newLinesSeen = 0;
	int currentIndex;
	int state = EStartOfComment;
	tagCommandLine.SetFileName(iCommentTagStore[i].GetFileName());
	int startLineNumber = iCommentTagStore[i].GetFirstLineOfComment();

	// parse all the comment tags to find definitions and values
	unsigned int originalNumberOfTokensInComment = iCommentTagStore[i].GetNumberOfTokensInComment();
	for(unsigned int j = 0; j < originalNumberOfTokensInComment; j++)
		{
		bool wordIsNewLine = iCommentTagStore[i].GetOriginalElement(j) == "\n" ? true : false;

		switch(state)
			{
			case(EStartOfComment):
				switch(wordIsNewLine)
					{
					case(true): 
						state = ENewLineAtStart;
						newLinesSeen++;
						break;
					default: 
						state = EAfterFirstWordOfTag;
						tagCommandLine.SetFirstLine(startLineNumber + newLinesSeen);
						tagCommandLine.SetLastLine(tagCommandLine.GetFirstLine());
 						tagCommandLine.AddElement(iCommentTagStore[i].GetOriginalElement(j));
					}
				break;
			case(EAfterFirstWordOfTag):
				switch(wordIsNewLine)
					{
					case(true):
						state = ENewLineInTag;
						newLinesSeen++;
						break;
					default:
						state = EInTag;
						tagCommandLine.AddElement( iCommentTagStore[i].GetOriginalElement(j) );
					}
				break;
			case(ENewLineAtStart):
				switch(wordIsNewLine)
					{
					case(true):
						newLinesSeen++;
						break;
					default:
						state = EAfterFirstWordOfTag;
						tagCommandLine.SetFirstLine(startLineNumber + newLinesSeen);
						tagCommandLine.SetLastLine( tagCommandLine.GetFirstLine() );
						tagCommandLine.AddElement( iCommentTagStore[i].GetOriginalElement(j) );
					}
				break;
			case(EInTag):
				switch(wordIsNewLine)
					{
					case(true):
						state = ENewLineInTag;
						newLinesSeen++;
						break;
					default:
						state = EInTag;
						tagCommandLine.AddElement( iCommentTagStore[i].GetOriginalElement(j) );
					}
				break;
			case(ENewLineInTag):
				{
				if(wordIsNewLine)
					{
					newLinesSeen++;
					}
				else if( iCommentTagStore[i].GetOriginalElement(j).FindSubString("@")==0)
					{
					iCommentTagStore[i].AddDataLine( tagCommandLine );
					currentIndex = iCommentTagStore[i].GetNumberOfLinesInComment()-1;
					Process(i, currentIndex);
					tagCommandLine.Empty();
					tagCommandLine.AddElement(iCommentTagStore[i].GetOriginalElement(j));
					tagCommandLine.SetFirstLine( startLineNumber + newLinesSeen );
					tagCommandLine.SetLastLine( tagCommandLine.GetFirstLine() );
					state = EAfterFirstWordOfTag;
					}
				else
					{
					state = EInTag;
					tagCommandLine.AddElement(iCommentTagStore[i].GetOriginalElement(j));
					tagCommandLine.SetLastLine( startLineNumber + newLinesSeen );
					}
				}
			}
		}

	if( tagCommandLine.GetNumberOfTokens() )
		{
		iCommentTagStore[i].AddDataLine( tagCommandLine );
		currentIndex = iCommentTagStore[i].GetNumberOfLinesInComment()-1;
		Process( i, currentIndex ); // process the current tag and parameters
		}
	iCommentTagStore[i].SetLastLine( startLineNumber + newLinesSeen );
	}


void GlobalLocalisationData::CheckIfCommentTagsFullyAnalysed()
	{
	for(unsigned int i = 0; i < iCommentTagStore.size(); i++)	//for each of the original comments sets whether or not all parts analysed
		{
		bool allAnalysed = true; //set to true then see if any are not analysed in which case will set to false
		unsigned int numberOfLinesInComment = iCommentTagStore[i].GetNumberOfLinesInComment();
		for(unsigned int j=0;j < numberOfLinesInComment && allAnalysed; j++)
			{
			if(iCommentTagStore[i].IsLineAnalysed(j) == false)
				allAnalysed = false;
			}
		if(allAnalysed)
			{
			iCommentTagStore[i].SetWholeTagAnalysed( true );
			}
		}
	}

void GlobalLocalisationData::CheckRlsEntries()
	{
	// check each rls item to see if there is a localisation comment before it

	TNameIndex::iterator end = pG->RlsNameIndex.end();
	String rlsTypeName;
	for (TNameIndex::iterator k = pG->RlsNameIndex.begin(); k != end; ++k)
		{
		int index = k->second;
		int rlsLineNumber = pG->RlsValues[index].iLineNumber;
		switch(pG->RlsValues[index].iType) 
			{
			case(ERlsString):
			case(ERlsStringChar):
				rlsTypeName = iRlsTypes[0];
				break;
			case(ERlsString8):
				rlsTypeName = iRlsTypes[1];
				break;
			case(ERlsByte):
			case(ERlsByteChar):
				rlsTypeName = iRlsTypes[2];
				break;
			case(ERlsWord):
			case(ERlsWordChar):
				rlsTypeName = iRlsTypes[3];
				break;
			case(ERlsLong):
			case(ERlsLongChar):
				rlsTypeName = iRlsTypes[4];
				break;
			case(ERlsDouble):
				rlsTypeName = iRlsTypes[5];
				break;
			default:
				rlsTypeName="";
			}
		const String rlsFileName = *(pG->RlsValues[index].iFileName);		
		int commentOfInterest = FindIndex(rlsFileName, rlsLineNumber);
		if(commentOfInterest == -1) // signifies there is no comment before rls declaration
			{
			Message * message = pG->Messages.GetEntry(LT_005);
			if(message->GetActivated())
				{
				pGL->AddWarningToStore(rlsFileName, rlsLineNumber, message->GetMessageOutput());
				}
			}
		else //know that there exists a tag directly before the rls item
			{
			CheckCommands(rlsTypeName, commentOfInterest);
			}
		}
	}

bool GlobalLocalisationData::LocalisationCommentsExist()
	{
	return (iCommentTagStore.size()) ? true : false;
	}

void GlobalLocalisationData::CheckCommands(String aRlsTypeName, int aCommentOfInterest)
	{
	std::vector<String> commentsSeen;
	unsigned int numberOfLines = iCommentTagStore[aCommentOfInterest].GetNumberOfLinesInComment();
	for(unsigned int j=0; j<numberOfLines; j++) // for each command in the particular comment
		{
		if(iCommentTagStore[aCommentOfInterest].IsLineAnalysed(j) == false)
			{
			iCommentTagStore[aCommentOfInterest].SetAnalysed( j, true );
			String commandName = iCommentTagStore[aCommentOfInterest].GetElementFromLine( j, 0 ); //gets tag value
			int length = commandName.Length();
			String tempCommandName = commandName.ExtractSubString(1, length-1); //strips off @ symbol

			int definitionNumber = iCommentDefinitions.size();
			for(int k=0; k<definitionNumber; k++) // finds tempCommandName in iCommentDefinitions
				if(iCommentDefinitions[k].GetCommandName() == tempCommandName)
					definitionNumber = k;

			if(definitionNumber == (int)iCommentDefinitions.size()) // if tempCommandName not found
				{
				Message * message = pG->Messages.GetEntry(LT_006);
				String fileName = iCommentTagStore[aCommentOfInterest].GetFileName();
				int lineNumber = iCommentTagStore[aCommentOfInterest].GetFirstLine(j);
				if(message->GetActivated())
					{
					pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
					}
				}
			else if(iCommentDefinitions[definitionNumber].TagDeclared() == false) // if tempCommandName not declared
				{
				Message * message = pG->Messages.GetEntry(LT_006);
				String fileName = iCommentTagStore[aCommentOfInterest].GetFileName();
				int lineNumber = iCommentTagStore[aCommentOfInterest].GetFirstLine(j);
				if(message->GetActivated())
					{
					pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
					}
				}
			else 
				{
				bool commentAlreadySeen=false;
				unsigned int numberOfCommentsSeen = commentsSeen.size();
				for(unsigned int k=0; k<numberOfCommentsSeen && commentAlreadySeen == false ;k++) 
					{ // checks in the commentsSeen vector for whether or not the tag has already been used
					if(commandName==commentsSeen[k])
						{
						Message * message = pG->Messages.GetEntry(LT_007);
						String fileName = iCommentTagStore[aCommentOfInterest].GetFileName();
						int lineNumber = iCommentTagStore[aCommentOfInterest].GetFirstLine(j);
						if(message->GetActivated())
							{
							pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
							}
						commentAlreadySeen = true;
						}
					}
				if(commentAlreadySeen == false)
					{
					commentsSeen.push_back(commandName); // new tag so store it
					if(iCommentDefinitions[definitionNumber].IsTagLegalForRlsType(aRlsTypeName) == false)
						{
						Message * message = pG->Messages.GetEntry(LT_008);
						String fileName =iCommentTagStore[aCommentOfInterest].GetFileName();
						int lineNumber = iCommentTagStore[aCommentOfInterest].GetFirstLine(j);
						if(message->GetActivated())
							{
							pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
							}
						}
					else
						{
						String parameterType = iCommentDefinitions[definitionNumber].GetParameterType();
						int numberOfArgs = iCommentTagStore[aCommentOfInterest].GetNumberOfTokensInLine(j) - 1;
						if(parameterType == "void")
							{
							if(numberOfArgs!=0) //void must have no arguments
								{	
								Message * message = pG->Messages.GetEntry(LT_009);
								String fileName =iCommentTagStore[aCommentOfInterest].GetFileName();
								int lineNumber = iCommentTagStore[aCommentOfInterest].GetFirstLine(j);
								if(message->GetActivated())
									{
									pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
									}
								}
							}
						else if(parameterType == "single")
							{
							if(numberOfArgs!=1) //single must have one argument
								{
								Message * message = pG->Messages.GetEntry(LT_010);
								String fileName =iCommentTagStore[aCommentOfInterest].GetFileName();
								int lineNumber = iCommentTagStore[aCommentOfInterest].GetFirstLine(j);
								if(message->GetActivated())
									{
									pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
									}							
								}
							else
								{
								CheckParametersArePermitted(aCommentOfInterest, j, definitionNumber);
								}
							}
						else if(parameterType == "multiple")
							{
							if(numberOfArgs<1) // multiple must have at least one argument
								{
								Message * message = pG->Messages.GetEntry(LT_011);
								String fileName =iCommentTagStore[aCommentOfInterest].GetFileName();
								int lineNumber = iCommentTagStore[aCommentOfInterest].GetFirstLine(j);
								if(message->GetActivated())
									{
									pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
									}	
								}
							else
								{
								CheckParametersArePermitted(aCommentOfInterest, j, definitionNumber);
								}
							}
						else if(parameterType == "text")
							{
							if(numberOfArgs<1) // text must have somethign after it so numberOfArgs must be >= 1
								{
								Message * message = pG->Messages.GetEntry(LT_012);
								String fileName =iCommentTagStore[aCommentOfInterest].GetFileName();
								int lineNumber = iCommentTagStore[aCommentOfInterest].GetFirstLine(j);
								if(message->GetActivated())
									{
									pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
									}	
								}
							}
						}
					}
				}
			}
		}
	CheckWhetherAllCommentsPresent(aRlsTypeName, aCommentOfInterest, commentsSeen);
	}

void GlobalLocalisationData::CheckWhetherAllCommentsPresent(String aRlsTypeName, int aCommentOfInterest, std::vector<String> aCommentsSeen)
	{
	for(unsigned int j=0; j<iCommentDefinitions.size(); j++)
		{
		bool commentAlreadyUsed = false;
		for(unsigned int k=0; k<aCommentsSeen.size() && commentAlreadyUsed == false;k++)
			{
			String storedCommandName = iCommentDefinitions[j].GetCommandName();
			String extractedCommandName = aCommentsSeen[k].ExtractSubString(1,aCommentsSeen[k].Length()-1);
			if(storedCommandName == extractedCommandName)
				{
				//this command already used in the comment tag
				commentAlreadyUsed = true;
				}
			}
		if(commentAlreadyUsed == false) // if tag wasn't present in the localisation comment
			{
			int requirementStatus = iCommentDefinitions[j].GetRequirementStatus(aRlsTypeName);
			if(iCommentDefinitions[j].GetRequirementStatus(aRlsTypeName) == ERequired) // if required emit warning
				{
				Message * message = pG->Messages.GetEntry(LT_013);
				String fileName = iCommentTagStore[aCommentOfInterest].GetFileName();
				int lineNumber = iCommentTagStore[aCommentOfInterest].GetLastLineOfComment() + 1;
				if(message->GetActivated())
					{
					String comment = message->GetMessageOutput();
					comment += iCommentDefinitions[j].GetCommandName();
					pGL->AddWarningToStore(fileName, lineNumber, comment);
					}
				}
			else if(requirementStatus == EOptionalWithDefault) // if optional check for default and add to file if default exists
				{
				String dataToAdd = iCommentDefinitions[j].CheckIfOptionalAndHasDefault(aRlsTypeName);
				if(dataToAdd != "")
					{
					iCommentTagStore[aCommentOfInterest].AddOptionalData(dataToAdd);
					}
				}
			}
		}
	}

void GlobalLocalisationData::CheckParametersArePermitted(int aCommentOfInterest, int aLineInComment, int aDefinitionNumber)
	{
	unsigned int elementsInLine = iCommentTagStore[aCommentOfInterest].GetNumberOfTokensInLine(aLineInComment);
	for(unsigned int j=1; j< elementsInLine;j++)
		{ // start iterating at 1 as 0th element is tag name
		bool parameterPermitted = false;
		unsigned int permissibleParameters = iCommentDefinitions[aDefinitionNumber].GetNumberOfPermissibleParameters();
		for(unsigned int k=0; k<permissibleParameters && parameterPermitted==false;k++)
			{
			if(iCommentTagStore[aCommentOfInterest].GetElementFromLine(aLineInComment,j)== iCommentDefinitions[aDefinitionNumber].GetPermissibleParameter(k))
				{
				parameterPermitted = true;
				}
			}
		if(parameterPermitted == false)
			{
			Message * message = pG->Messages.GetEntry(LT_014);
			String fileName = iCommentTagStore[aCommentOfInterest].GetFileName();
			int lineNumber = iCommentTagStore[aCommentOfInterest].GetFirstLine(aLineInComment);
			if(message->GetActivated())
				{
				pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
				}
			return;
			}
		}
	}

int GlobalLocalisationData::FindIndex(const String aFileName, int aLineNumber)
	{
	for(unsigned int j=0;j<iCommentTagStore.size(); j++)
		{
		if(iCommentTagStore[j].GetFileName() == aFileName)
			{
			if(iCommentTagStore[j].GetLastLineOfComment() == aLineNumber - 1)
				{
				return j;
				}
			}
		}
	return -1; //signifies that there is no localisation comment preceding this rls line
	}


bool GlobalLocalisationData::CheckFirstIsCommand(LocalisationLine aCommandLine)
	{
	return aCommandLine.GetElement(0).FindSubString("@") == 0 ? true : false;
	}

void GlobalLocalisationData::StoreFinalComment()
	{
	if(iTempCommentStore.GetFirstLine() >= 0)
		AddCommentToStore();
	}

void GlobalLocalisationData::StoreComment(String aString) 
	{
	iTempCommentStore.AddElement(aString);
	}

void GlobalLocalisationData::Process(unsigned int aStoreIndex, unsigned int aCurrentIndex)
	{
	LocalisationLine tagCommandLine(iCommentTagStore[aStoreIndex].GetLine(aCurrentIndex));
	String firstWord = tagCommandLine.GetElement(0);
	iCommentTagStore[aStoreIndex].SetAnalysed(aCurrentIndex, true); // will reset to false if turns out not to be a declaration
	if(firstWord == "@declaretag") 
		ProcessDeclaration(aStoreIndex, aCurrentIndex);
	else if(firstWord == "@tagvalue")
		ProcessTagParameter(aStoreIndex, aCurrentIndex);
	else if(firstWord == "@tagoptional")
		{
		ProcessOptional(aStoreIndex, aCurrentIndex);
		}
	else if(firstWord == "@tagrequired")
		ProcessRequired(aStoreIndex, aCurrentIndex);
	else if(firstWord[0]=='@') // must be a tag like 'localise' or 'description'
		{
		iCommentTagStore[aStoreIndex].SetAnalysed(aCurrentIndex, false);
		}
	else // first word on a line (not wrapping over from a previous line) does not start with an @ symbol, enit warning
		{
		Message * message = pG->Messages.GetEntry(LT_015);
		String fileName = tagCommandLine.GetFileName();
		int lineNumber = tagCommandLine.GetFirstLine();
		if(message->GetActivated())
			{
			pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
			}
		}
	}

void GlobalLocalisationData::ProcessDeclaration(unsigned int aStoreIndex, unsigned int aCurrentIndex)
	{
	LocalisationLine tagDeclarationLine(iCommentTagStore[aStoreIndex].GetLine(aCurrentIndex));
	if(tagDeclarationLine.GetNumberOfTokens()!=3) // tag declaration lines must have three words in them
		{
		Message * message = pG->Messages.GetEntry(LT_016);
		String fileName = tagDeclarationLine.GetFileName();
		int lineNumber = tagDeclarationLine.GetFirstLine();
		if(message->GetActivated())
			{
			pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
			}
		return;
		}
	String tagType = tagDeclarationLine.GetElement(1);
	bool acceptableParameter = false; // check that tagType is one of void, single, multiple or text
	for(int i=0; i<4 && acceptableParameter == false; i++)
		{
		if(tagType == iTypes[i])
			{
			acceptableParameter = true;
			}
		}
	if(acceptableParameter == false)
		{
		Message * message = pG->Messages.GetEntry(LT_017);
		String fileName = tagDeclarationLine.GetFileName();
		int lineNumber = tagDeclarationLine.GetFirstLine();
		if(message->GetActivated())
			{
			pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
			}
		return;
		}
	if(tagDeclarationLine.GetElement(2).FindSubString("@")==0)
		{
		Message * message = pG->Messages.GetEntry(LT_018);
		String fileName = tagDeclarationLine.GetFileName();
		int lineNumber = tagDeclarationLine.GetFirstLine();
		if(message->GetActivated())
			{
			pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
			}
		return;
		}
	String tagName = tagDeclarationLine.GetElement(2);
	CommentTagPair dataToAdd(tagName, tagType, true);
	int entryNumber = GetTagDeclaredIndex(tagName); // check whether tag has already been declared
	if(entryNumber == EStringNotFound) // if not then add to store
		{
		iCommentDefinitions.push_back( dataToAdd );
		}
	else if(iCommentDefinitions[entryNumber].TagDeclared()) // emit warning if declared
		{
		Message * message = pG->Messages.GetEntry(LT_019);
		String fileName = tagDeclarationLine.GetFileName();
		int lineNumber = tagDeclarationLine.GetFirstLine();
		if(message->GetActivated())
			{
			pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
			}
		}
	else
		iCommentDefinitions[entryNumber].SetTagDeclared(); // set tag as declared
	}

void GlobalLocalisationData::StoreTagParameter(String aCommandName, String aParameter)
	{
	int entryNumber = GetTagDeclaredIndex(aCommandName);
	iCommentDefinitions[entryNumber].AddPermissibleParameter(aParameter);
	}

int GlobalLocalisationData::GetTagDeclaredIndex(String aCommandName)
	{ // return index number of tag in iCommentDefinitions store
	for(unsigned int j = 0; j < iCommentDefinitions.size(); j++)
		{
		if(iCommentDefinitions[j].GetCommandName() == aCommandName)
			{
			return j;
			}
		}
	return -1;
	}

void GlobalLocalisationData::ProcessTagParameter(unsigned int aStoreIndex, unsigned int aCurrentIndex)
	{
	LocalisationLine tagParameterLine(iCommentTagStore[aStoreIndex].GetLine(aCurrentIndex));
	if(tagParameterLine.GetNumberOfTokens()!=3)
		{
		Message * message = pG->Messages.GetEntry(LT_020);
		String fileName = tagParameterLine.GetFileName();
		int lineNumber = tagParameterLine.GetFirstLine();
		if(message->GetActivated())
			{
			pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
			}
		return;
		}
	String tagName = tagParameterLine.GetElement(1);
	if(tagName.FindSubString("@") == 0)
		{
		Message * message = pG->Messages.GetEntry(LT_021);
		String fileName = tagParameterLine.GetFileName();
		int lineNumber = tagParameterLine.GetFirstLine();
		if(message->GetActivated())
			{
			pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
			}
		return;
		}
	int entryNumber = GetTagDeclaredIndex(tagName);
	String parameter = tagParameterLine.GetElement(2);
	if(entryNumber == -1) // if tag not declared then add to store, doesn't set tag as declared though as haven't seen a @declaretag line for this tag
		{
		CommentTagPair dataToAdd(tagName);
		iCommentDefinitions.push_back(dataToAdd);
		}
	else
		{
		// check whether this parameter has alreasy been declared for this tag
		bool alreadyDeclared = iCommentDefinitions[entryNumber].IsParameterAlreadyDeclared(parameter);
		if(alreadyDeclared)
			{
			Message * message = pG->Messages.GetEntry(LT_022);
			String fileName = tagParameterLine.GetFileName();
			int lineNumber = tagParameterLine.GetFirstLine();
			if(message->GetActivated())
				{
				pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
				}
			return;
			}
		}
	StoreTagParameter(tagName, parameter); // store the parameter if all conditions met
	}

void GlobalLocalisationData::ProcessRequired(unsigned int aStoreIndex, unsigned int aCurrentIndex)
	{
	LocalisationLine tagRequiredLine(iCommentTagStore[aStoreIndex].GetLine(aCurrentIndex));

	// @tagrequired line must consist of three distinct tokens

	if(tagRequiredLine.GetNumberOfTokens()!=3)
		{
		Message * message = pG->Messages.GetEntry(LT_023);
		String fileName = tagRequiredLine.GetFileName();
		int lineNumber = tagRequiredLine.GetFirstLine();
		if(message->GetActivated())
			{
			pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
			}
		return;
		}

	// get the tag name and check it doesn't start with an @ symbol
	
	String tagName = tagRequiredLine.GetElement(1);
	if(tagName.FindSubString("@")==0)
		{
		Message * message = pG->Messages.GetEntry(LT_024);
		String fileName = tagRequiredLine.GetFileName();
		int lineNumber = tagRequiredLine.GetFirstLine();
		if(message->GetActivated())
			{
			pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
			}
		return;
		}

	String rlsItem = tagRequiredLine.GetElement(2);

	//check that the rls type passed is one of the legally allowed values

	bool validRlsFlag = false;
	for(int j=0; (j < ENumberOfRlsTypes) && (validRlsFlag == false); j++)
		{
		if(rlsItem == iRlsTypes[j])
			{
			validRlsFlag = true;
			}
		}
	if(validRlsFlag == false)
		{
		Message * message = pG->Messages.GetEntry(LT_036);
		String fileName = tagRequiredLine.GetFileName();
		int lineNumber = tagRequiredLine.GetFirstLine();
		if(message->GetActivated())
			{
			String comment = message->GetMessageOutput();
			comment += rlsItem;
			pGL->AddWarningToStore(fileName, lineNumber, comment);
			}
		return;
		}
	

	// store the data

	int entryNumber = GetTagDeclaredIndex(tagName);
	if(entryNumber == -1)
		{
		CommentTagPair dataToAdd(tagName);
		iCommentDefinitions.push_back(dataToAdd);
		}
	else
		{
		int requirementStatus = iCommentDefinitions[entryNumber].GetRequirementStatus(rlsItem);
		if(requirementStatus != EForbidden)
			{
			Message * message = pG->Messages.GetEntry(LT_025);
			String fileName = tagRequiredLine.GetFileName();
			int lineNumber = tagRequiredLine.GetFirstLine();
			if(message->GetActivated())
				{
				pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
				}
			return;
			}
		}
	StoreRlsItem(tagName, tagRequiredLine.GetElement(2), ERequired);
	}

void GlobalLocalisationData::StoreRlsItem(String aCommandName, String aRlsItem, int aRequired, String aDefault)
	{
	int entryNumber = GetTagDeclaredIndex(aCommandName);
	iCommentDefinitions[entryNumber].AddRlsItem(aRlsItem,aRequired,aDefault);
	}

bool GlobalLocalisationData::IsAnRlsItem(String aString) const
	{
	//check whether aString is one of the legally allowed rls items

	for(int j=0; j < ENumberOfRlsTypes ; j++)
		{
		if(aString == iRlsTypes[j])
			{
			return true;
			}
		}
	return false;
	}

void GlobalLocalisationData::ProcessOptional(unsigned int aStoreIndex, unsigned int aCurrentIndex)
	{
	LocalisationLine tagOptionalLine(iCommentTagStore[aStoreIndex].GetLine(aCurrentIndex));
	int tagLineSize = tagOptionalLine.GetNumberOfTokens();
	
	String fileName = tagOptionalLine.GetFileName();
	int lineNumber = tagOptionalLine.GetFirstLine();
	String comment;
	
	String commandName;
	String defaultValue;
	String rlsItem;
	bool validOptionalDeclaration = false; // will be set to true if the line conforms to the accepted syntax

	unsigned int state = ELookingForCommand;
	int firstOccurance;
	String currentToken;

	for(int j=1; j<tagLineSize; j++) // start at 1 as 0th element is @tagoptional
		{
		currentToken = tagOptionalLine.GetElement(j);
		switch(state)
			{
			case(ELookingForCommand):
				firstOccurance = currentToken.FindSubString("=");
				if(firstOccurance == EStringNotFound)
					{
					if(IsAnRlsItem(currentToken))
						{
						Message * message = pG->Messages.GetEntry(LT_038);
						if(message->GetActivated())
							{
							pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
							}
						return;
						}
					else
						{
						commandName = currentToken;
						state = ELookingForEqualSignOrRlsItem;
						}
					}
				else if(firstOccurance == 0) // = sign is at the start
					{
					Message * message = pG->Messages.GetEntry(LT_039);
					if(message->GetActivated())
						{
						pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
						}
					return;
					}
				else if(currentToken.FindSubString("=",firstOccurance+1)!=EStringNotFound) // more than one = sign
					{
					Message * message = pG->Messages.GetEntry(LT_027);
					if(message->GetActivated())
						{
						pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
						}
					return;
					}
				else if((unsigned int)firstOccurance == currentToken.Length() - 1) // = sign at end
					{
					commandName = currentToken.ExtractSubString( 0, currentToken.Length()-2 );
					state = ELookingForDefault;
					}
				else // know that is of from <string1>=<string2>
					{
					commandName = currentToken.ExtractSubString( 0, firstOccurance - 1 );
					defaultValue = currentToken.ExtractSubString( firstOccurance + 1, currentToken.Length()-1 );
					if(IsAnRlsItem(commandName))
						{
						Message * message = pG->Messages.GetEntry(LT_040);
						if(message->GetActivated())
							{
							pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
							}
						return;
						}
					else if(IsAnRlsItem(defaultValue))
						{
						Message * message = pG->Messages.GetEntry(LT_041);
						if(message->GetActivated())
							{
							pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
							}
						return;
						}
					else // no problems so go and look next for an rls item
						{
						state = ELookingForRlsItem;
						}
					}
				break;
			case(ELookingForEqualSignOrRlsItem):
				firstOccurance = currentToken.FindSubString("=");
				if(firstOccurance == EStringNotFound) // element must be rls item or error
					{
					if(IsAnRlsItem(currentToken))
						{
						rlsItem = currentToken;
						state = EShouldBeFinished;
						validOptionalDeclaration = true;
						}
					else // not an rls item
						{
						Message * message = pG->Messages.GetEntry(LT_035);
						if(message->GetActivated())
							{
							String comment = message->GetMessageOutput();
							comment += currentToken;
							pGL->AddWarningToStore(fileName, lineNumber, comment);
							}
						return;
						}
					}
				else if(currentToken.FindSubString("=",firstOccurance+1)!=EStringNotFound) // more than one = sign
					{
					Message * message = pG->Messages.GetEntry(LT_027);
					if(message->GetActivated())
						{
						pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
						}
					return;
					}
				else if(firstOccurance != 0) // = sign not at start
					{
					Message * message = pG->Messages.GetEntry(LT_042);
					if(message->GetActivated())
						{
						pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
						}
					return;
					}
				else if(currentToken.Length() == 1) // = sign by itself
					{
					state = ELookingForDefault;
					}
				else
					{
					defaultValue = currentToken.ExtractSubString( 1, currentToken.Length()-1 );
					if(IsAnRlsItem(defaultValue)) // if found rls item where default value should be
						{
						Message * message = pG->Messages.GetEntry(LT_041);
						if(message->GetActivated())
							{
							pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
							}
						return;
						}
					else
						{
						state = ELookingForRlsItem;
						}
					}
				break;
			case(ELookingForDefault):
				firstOccurance = currentToken.FindSubString("=");
				if(firstOccurance != EStringNotFound) // should not find any more equal signs on the line
					{
					Message * message = pG->Messages.GetEntry(LT_027);
					if(message->GetActivated())
						{
						pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
						}
					return;
					}
				else
					{
					defaultValue = currentToken;
					if(IsAnRlsItem(defaultValue)) //check that default value is not an rls item
						{
						Message * message = pG->Messages.GetEntry(LT_041);
						if(message->GetActivated())
							{
							pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
							}
						return;
						}
					else
						{
						state = ELookingForRlsItem;
						}
					}
				break;
			case(ELookingForRlsItem):
				rlsItem = currentToken;
				if(IsAnRlsItem(rlsItem) == false)
					{
					Message * message = pG->Messages.GetEntry(LT_035);
					if(message->GetActivated())
						{
						String comment = message->GetMessageOutput();
						comment += rlsItem;
						pGL->AddWarningToStore(fileName, lineNumber, comment);
						}
					return;
					}
				else
					{
					state = EShouldBeFinished;
					validOptionalDeclaration = true;
					}
				break;
			case(EShouldBeFinished):
				Message * message = pG->Messages.GetEntry(LT_043);
				if(message->GetActivated())
					{
					String comment = message->GetMessageOutput();
					comment += currentToken;
					pGL->AddWarningToStore(fileName, lineNumber, comment);
					}
				return;
			}
		}

	if(validOptionalDeclaration == false) // end of line reached prematurely
		{
		Message * message = pG->Messages.GetEntry(LT_044);
		if(message->GetActivated())
			{
			pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
			}
		return;
		}


	int entryNumber = GetTagDeclaredIndex(commandName);
	if(entryNumber == -1)
		{
		CommentTagPair dataToAdd(commandName);
		iCommentDefinitions.push_back(dataToAdd);
		}
	else
		{
		int requirementStatus = iCommentDefinitions[entryNumber].GetRequirementStatus(rlsItem);
		if(requirementStatus != EForbidden)
			{
			Message * message = pG->Messages.GetEntry(LT_025);
			if(message->GetActivated())
				{
				pGL->AddWarningToStore(fileName, lineNumber, message->GetMessageOutput());
				}
			return;
			}
		}
	
	if(defaultValue.Length())
		StoreRlsItem(commandName, rlsItem, EOptionalWithDefault, defaultValue);
	else
		StoreRlsItem(commandName, rlsItem, EOptional);
	}
			

void GlobalLocalisationData::AddWarningToStore(const String aFileName, int aLineNumber, String aComment)
	{
	WarningToOutput warning(aFileName, aLineNumber, aComment);
	iWarningStore.push_back(warning);
	}

void GlobalLocalisationData::PrintLocalisationWarnings()
	{
	std::vector<WarningToOutput> warningStore;
	unsigned int j;
	unsigned int numberOfWarnings = iWarningStore.size();
	std::vector<int> flags;
	for(j=0 ; j<numberOfWarnings; j++)
		{
		warningStore.push_back(iWarningStore[j]);
		flags.push_back(1);
		}

	iWarningStore.clear();
	StringLess stringCompare;
	int currentBestIndex;
	int totalLeft = numberOfWarnings;
	while(totalLeft) // loop orders stored warnings alphabetically by file name and then by line number
		{
		String fileName;
		int lineNumber = -1;
		String comment;
		String currentBestFileName;
		int currentBestLineNumber = -1;
		String currentBestComment;
		bool beforeFirst = true;
		for(j=0,totalLeft=0,currentBestIndex=-1; j< numberOfWarnings; j++)
			{
			if(flags[j])
				{
				if(beforeFirst)
					{
					currentBestFileName = warningStore[j].GetFileName();
					currentBestLineNumber = warningStore[j].GetLineNumber();
					currentBestComment = warningStore[j].GetComment();
					currentBestIndex = j;
					beforeFirst = false;
					}
				else 
					{
					fileName = warningStore[j].GetFileName();
					lineNumber = warningStore[j].GetLineNumber();
					comment = warningStore[j].GetComment();
					if(!stringCompare(fileName, currentBestFileName) && !stringCompare(currentBestFileName, fileName))
						{
						if(lineNumber < currentBestLineNumber)
							{
							currentBestLineNumber = lineNumber;
							currentBestComment = comment;
							currentBestIndex = j;
							}
						}
					else if(stringCompare(fileName, currentBestFileName))
						{
						currentBestFileName = fileName;
						currentBestLineNumber = lineNumber;
						currentBestComment = comment;
						currentBestIndex = j;
						}
					}
				totalLeft++;
				}
			}
		if(currentBestIndex>=0)
			{
			flags[currentBestIndex]=0;
			WarningToOutput warning(warningStore[currentBestIndex]);
			iWarningStore.push_back(warning);
			totalLeft--;
			}
		}
	for(j=0; j< numberOfWarnings; j++) // outputs warning in alphabetical file order, by line number within a file
		{
		String fileName = iWarningStore[j].GetFileName();
		ErrorHandler::Register(& fileName, iWarningStore[j].GetLineNumber());
		ErrorHandler::OutputErrorLine(iWarningStore[j].GetComment());
		}
	}

void GlobalLocalisationData::OutputLocalisedFile(String SourceFileName)
	{ // reparse the source file and output a file with the optional tags with defaults added in

	char fileChar;
	char * fileCharAsArray = new char[2];
	fileCharAsArray[0] = 'a';
	fileCharAsArray[1]='\0';
	const char * fileName = SourceFileName.GetAssertedNonEmptyBuffer();
	ifstream iFile(fileName);

	char * LocalisationOutputFileName;
	LocalisationOutputFileName = tmpnam(NULL);
	ofstream outputFile(LocalisationOutputFileName);

	String fileLine("");
	int fileLineLength = fileLine.Length();
	int previousState;
	int state = EStartOfLine;
	int currentFileLine = 1;
	String currentFileName = SourceFileName;
	int newLineNumber = -1;
	String newFileName("");
	String newLineNumberAsString("");
	bool validLine = false;
	while(iFile.get(fileChar)) // read file character by character looking for file declaration lines
		{
		fileCharAsArray[0]=fileChar;
		if(state == EStartOfLine) // add character to store of this line
			fileLine = fileCharAsArray;
		else
			fileLine += fileCharAsArray;
		previousState = state;
		switch(state)
			{
			case(EStartOfLine):
				switch(fileChar)
					{
					case('#'):
						state = EFindLineNo;
						break;
					case('\n'):
						break;
					default:
						state = EGeneral;
					}
				break;
			case(EGeneral):
				switch(fileChar)
					{
					case('\n'):
						state = EStartOfLine;
						break;
					}
				break;
			case(EFindLineNo):
				switch(fileChar)
					{
					case('\n'):
						state = EStartOfLine;
						break;
					case('0'):
					case('1'):
					case('2'):
					case('3'):
					case('4'):
					case('5'):
					case('6'):
					case('7'):
					case('8'):
					case('9'):
						state = EInLineNo;
						break;
					case(' '):
					case('\t'):
						break;
					default:
						state = EGeneral;
					}
				break;
			case(EInLineNo):
				switch(fileChar)
					{
					case('\n'):
						state = EStartOfLine;
						break;
					case('0'):
					case('1'):
					case('2'):
					case('3'):
					case('4'):
					case('5'):
					case('6'):
					case('7'):
					case('8'):
					case('9'):
						break;
					case(' '):
					case('\t'):
						state = EFindFileName;
						break;
					default:
						state = EGeneral;
					}
				break;
			case(EFindFileName):
				switch(fileChar)
					{
					case('\n'):
						state = EStartOfLine;
						break;
					case(' '):
					case('\t'):
						break;
					case('\"'):
						state = EInFileName;
						break;
					default:
						state = EGeneral;
					}
				break;
			case(EInFileName):
				switch(fileChar)
					{
					case('\n'):
						state = EStartOfLine;
						break;
					case(' '):
					case('\t'):
						state = EGeneral;
						break;
					case('\"'):
						state = EFindDigit;
						break;
					}
				break;
			case(EFindDigit):
				switch(fileChar)
					{
					case('\n'):
						state = EStartOfLine;
						break;
					case(' '):
					case('\t'):
						break;
					case('1'):
					case('2'):
						state = EAfterDigit;
						break;
					default:
						state = EGeneral;
					}
				break;
			case(EAfterDigit):
				switch(fileChar)
					{
					case('\n'):
						state = EStartOfLine;
						break;
					case(' '):
					case('\t'):
						break;
					default:
						state = EGeneral;
					}
				break;
			}
		int lineOfInterest;
		switch(state)
			{
			case(EStartOfLine):
				if(validLine) //validline will be true if this line is a file line declaration
					{
					currentFileName = newFileName;
					currentFileLine = newLineNumber - 1;
					}
				validLine = false;
				newFileName.Reset();
				newLineNumber = -1;
				newLineNumberAsString.Reset();
				fileLineLength = fileLine.Length();
				lineOfInterest = NeedToAddDefaultData(currentFileName, currentFileLine); //checks if previous line was the end of a localisation tag and whether that tag has optional data to add
				if(lineOfInterest > -1)		// data to add									   
					{
					int end = fileLine.FindSubString("*/");
					String tempString;
					if(end)
						{
						tempString = fileLine.ExtractSubString(0,end-1);
						outputFile.write(tempString.GetBuffer(),tempString.Length());
						outputFile.write("\n",1);
						}
					unsigned int numberOfLinesToAdd = iCommentTagStore[lineOfInterest].GetNumberOfOptionalLinesToAdd();
					for(unsigned int j=0; j<numberOfLinesToAdd; j++)
						{
						tempString = iCommentTagStore[lineOfInterest].GetOptionalLineToAdd(j);
						const char * pTempString = tempString.GetBuffer();
						outputFile.write(pTempString,tempString.Length()-1);
						outputFile.write("\n",1);
						}
					tempString = fileLine.ExtractSubString(end, fileLine.Length()-1);
					outputFile.write(tempString.GetBuffer(),tempString.Length());
					}
				else
					outputFile.write(fileLine.GetBuffer(), fileLineLength);
				fileLine.Reset();
				currentFileLine++;
				break;
			case(EGeneral):
				if(previousState!=EGeneral)
					{
					newLineNumber = -1;
					newLineNumberAsString.Reset();
					newFileName.Reset();
					validLine = false;
					}
				break;
			case(EInLineNo):
				if(newLineNumberAsString.Length())
					newLineNumberAsString+= fileCharAsArray;
				else
					newLineNumberAsString = fileCharAsArray;
				break;
			case(EFindFileName):
				if(previousState == EInLineNo)
					{
					newLineNumber = newLineNumberAsString.Atoi();
					}
				break;
			case(EInFileName):
				if(previousState == EInFileName)
					{
					if(newFileName.Length())
						newFileName += fileCharAsArray;
					else
						newFileName  = fileCharAsArray;
					}
				break;
			case(EFindDigit):
				if(previousState == EInFileName)
					validLine = true;
				break;
			}
		}
		iFile.close();
		outputFile.close();
		if(remove(fileName) != 0)
			{
			Message * message = pG->Messages.GetEntry(LT_037);
			if(message->GetActivated())
				{
				cerr << message->GetMessageOutput() << endl;
				}			
			}
		else
			{
			rename(LocalisationOutputFileName, fileName);
			}
		delete []fileCharAsArray;
	}


#ifdef __VC32__
#pragma warning( pop )
#endif