// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Implementation of the Class DefFile for the elf2e32 tool

// @internalComponent

// @released

// 

//

//

#include <cstdio>

#include <cstring>

#include <iostream>

#include <cstdlib>

#include "pl_symbol.h"

#include "deffile.h"

#include "errorhandler.h"

#ifdef __LINUX__

    #include "h_utl.h"

    #define STRUPR strupr

#else 

    #define STRUPR _strupr

#endif

using std::cerr;

using std::cout;

using std::endl;

#define SUCCESS 1

#define FAILURE 0

/**

Destructor to release all the allocated memory

@internalComponent

@released

*/

DefFile::~DefFile()

{

	if(iSymbolList && iSymbolList->size())

	{

		SymbolList::iterator aItr = iSymbolList->begin();

		SymbolList::iterator last = iSymbolList->end();

		Symbol *temp;

		while(aItr != last)

		{

			temp = *aItr;

			aItr++;

			delete temp;

		}

		iSymbolList->clear();

	}

	delete iSymbolList;

}

/**

Function to Get File Size.

@param fptrDef - File pointer to DEF file

@internalComponent

@released

*/

int DefFile::GetFileSize(FILE *fptrDef)

{

	int fileSize,status;

	status=fseek(fptrDef, 0, SEEK_END);

	if(status!=0)

	{

		throw FileError(FILEREADERROR,iFileName);

	}

	fileSize=ftell(fptrDef);

	rewind(fptrDef);

	return fileSize;

}

/**

Function to Open File and read it in memory.

@param defFile - DEF File name

@internalComponent

@released

*/

char* DefFile::OpenDefFile(char * defFile)

{

	int fileSize;

	char *defFileEntries;

	FILE *fptrDef;

	iFileName=defFile;

	if((fptrDef=fopen(defFile,"rb"))==NULL)

	{

		throw FileError(FILEOPENERROR,defFile);

	}

	fileSize=GetFileSize(fptrDef);

	if((defFileEntries= new char[fileSize+2]) ==NULL)

	{

		throw MemoryAllocationError(MEMORYALLOCATIONERROR,defFile);

	}

	//Getting whole file in memory

	if(!fread(defFileEntries, fileSize, 1, fptrDef))

	{

		throw FileError(FILEREADERROR,defFile);

	}

	//Adding ENTER at end

	*(defFileEntries+fileSize)='\n';

	//Adding '\0' at end

	*(defFileEntries+fileSize+1)='\0';

	fclose(fptrDef);

	return defFileEntries;

}

/**

Function to Parse Def File which has been read in buffer.

@param defFileEntries - pointer to def file entries which has been read in buffer

@internalComponent

@released

*/

void DefFile::ParseDefFile(char *defFileEntries)

{

	iSymbolList = new SymbolList;

	int ordinalNo = 0;

	int symbolType=SymbolTypeCode;

	int PreviousOrdinal=0;

	char MultiLineStatement[1024]="";

	bool NAMEorLIBRARYallowed=true;

	int LineNum = 0;

	bool isComment;

	char *lineToken;

	int aLineLength = 0, width = 0;

	unsigned i;

	char *ptrEntry,*ptrEntryType;

	char entryType[256];

	bool entryFlag;

	lineToken=strtok(defFileEntries,"\n");

	while(lineToken != NULL)

	{

		symbolType=SymbolTypeCode;

		isComment=false;

		entryType[0]='\0';

		aLineLength = strlen(lineToken);

		LineNum++;

		if (lineToken == NULL || lineToken[0]==13)

		{

			lineToken=strtok(NULL,"\n");

			continue;

		}

		// comment lines

		if (lineToken[0] == ';')

		{

			lineToken=strtok(NULL,"\n");

			continue;

		}

		ptrEntry=lineToken;

		if((!strstr(lineToken, "NONAME") && ((ptrEntryType=strstr(lineToken, "NAME")) != NULL)) ||

			((ptrEntryType=strstr(lineToken, "EXPORTS")) != NULL) ||

			((ptrEntryType=strstr(lineToken, "IMPORTS")) != NULL) ||

			((ptrEntryType=strstr(lineToken, "SECTIONS")) != NULL) ||

			((ptrEntryType=strstr(lineToken, "LIBRARY")) != NULL) ||

			((ptrEntryType=strstr(lineToken, "DESCRIPTION")) != NULL)||

			((ptrEntryType=strstr(lineToken, "STACKSIZE")) != NULL)||

			((ptrEntryType=strstr(lineToken, "VERSION")) != NULL)

			)

		{

			entryFlag=true;

			for(i=0; ptrEntry!=ptrEntryType; i++,ptrEntry++)

			{

				switch(lineToken[i])

				{

				case ' ':

				case '\t':

					continue;

				default:

					entryFlag=false;

					break;

				}

				if(entryFlag==false)

					break;

			}

			if(entryFlag==false && !strcmp(MultiLineStatement,""))

			{

				throw DEFFileError(UNRECOGNIZEDTOKEN,iFileName,LineNum,lineToken);

			}

			if(entryFlag==true)

			{

				switch(ptrEntryType[0])

				{

				case 'E':

				case 'I':

				case 'L':

				case 'V':

					width=7;

					break;

				case 'S':

					if(ptrEntryType[1]=='E')

						width=8;

					else

						width=9;

					break;

				case 'N':

					width=4;

					break;

				case 'D':

					width=11;

					break;

				}

			}

			if(entryFlag==true)

			{

  				for(i=i+width; i<strlen(lineToken); i++)

				{

					switch(lineToken[i])

					{

					case ' ':

					case '\t':

						continue;

					case '\r':

					case '\0':

						break;

					default:

						entryFlag=false;

						break;

					}

					if(entryFlag==false)

						break;

				}

			}

			if(entryFlag==false && !strcmp(MultiLineStatement,""))

			{

				throw DEFFileError(UNRECOGNIZEDTOKEN,iFileName,LineNum,lineToken+i);

			}

			if(entryFlag==true)

			{

				strncpy(entryType, ptrEntryType, width);

				entryType[width]='\0';

				switch(ptrEntryType[0])

				{

				case 'E':		// check for multi-line sections starting

					strcpy(MultiLineStatement, STRUPR(entryType)); // Uppercase token

					NAMEorLIBRARYallowed = false;

					lineToken = strtok(NULL, "\n" ); // Get the next line

					continue;

				case 'N':

					break;

				case 'L':

					break;

				case 'D':

					break;

				case 'S':

				case 'V':

					if(entryType[1]!='E')

					{

						// set MULTI-LINE statement to OFF

						strcpy(MultiLineStatement, STRUPR(entryType)); // Uppercase token

						// check single-line statements are specified correctly

						// check NAME or LIBRARY statements aren't supplied incorrectly

						if (!strcmp(entryType, "NAME") ||

							!strcmp(entryType, "LIBRARY")

							)

						{

							if (NAMEorLIBRARYallowed == false)

							{

								throw DEFFileError(NAMELIBRARYNOTCORRECT,iFileName,LineNum,lineToken);

							}

							lineToken=strtok(NULL,"\n");

							continue;

						}

						NAMEorLIBRARYallowed = false;

						lineToken=strtok(NULL,"\n");

						continue;

					}

					continue;

				case 'I':

					strcpy(MultiLineStatement, STRUPR(entryType)); // Uppercase token

					lineToken = strtok(NULL, "\n" ); // Get the next line

					continue;

				}

			}

		}

		else

		{

			if (!strcmp(MultiLineStatement,""))

		    {

				throw DEFFileError(EXPORTSEXPECTED,iFileName,LineNum,lineToken);

			}

		}	

		// Get Export entries

		if (!strcmp(MultiLineStatement,"EXPORTS"))

		{

			Symbol aSymbol(NULL, SymbolTypeCode);

			if( Tokenize(lineToken, LineNum, aSymbol) )

			{

				Symbol *newSymbolEntry = new Symbol(aSymbol);

				iSymbolList->push_back(newSymbolEntry);

				ordinalNo = aSymbol.OrdNum();

				//Check for ordinal sequence

				if (ordinalNo != PreviousOrdinal+1)

		   		{

					throw DEFFileError(ORDINALSEQUENCEERROR,iFileName,LineNum,(char*)aSymbol.SymbolName());

				}

				PreviousOrdinal = ordinalNo;

			}

			lineToken=strtok(NULL,"\n");

			continue;

		}

		else if(strcmp(MultiLineStatement,"")!=0)//For entry other than exports

			lineToken = strtok(NULL, "\n" ); // Get the next line

	}//End of while

}

/**

This Function calls LineToken's Tokenize function.

@param aTokens   - Input string at the current line number

@param aLineNum  - Current line number

@param aSymbol   - Symbol to be populated while parsing the line.

Return value     - It returns true if a valid def file entry is found.

@internalComponent

@released

*/

bool DefFile::Tokenize(char* aTokens, int aLineNum, Symbol& aSymbol)

{

	/*

	 * Pattern to match is:

	 * START\s*(\S+)\s+@\s*(d+)\s*(NONAME)?\s*(R3UNUSED)?\s*(ABSENT)?\s*(;\s*(.*))END

	 */

	LineToken aLine(iFileName, aLineNum, aTokens, &aSymbol);

	return aLine.Tokenize();

}

char * DefFilePatterns[] =

	{

		"NONAME",//index 0

		"DATA",

		"R3UNUSED",

		"ABSENT"

	};

#define DEF_NONAME		0

#define DEF_DATA		1

#define DEF_R3UNUSED	2

#define DEF_ABSENT		3

/**

This constructor creates an instance of LineToken class.

@param aFileName - Def File Name.

@param aLineNum  - Current line number

@param aLn       - Input string at the current line number

@param aSym      - Symbol to be populated while parsing the line.

@internalComponent

@released

*/

LineToken::LineToken(char* aFileName, int aLineNum, char *aLn, Symbol* aSym) : \

		iLine(aLn) , iSymbol(aSym) , iOffset(0), iState(EInitState),iFileName(aFileName), iLineNum(aLineNum) 

{

}

/**

This function tokenizes the line and populates a symbol entry 

if there is one.

Return Value - True, if the current line has a valid def entry.

@internalComponent

@released

*/

bool LineToken::Tokenize()

{

	while (1) 

	{

		switch( iState )

		{

		case EFinalState:

			return true;

		case EInitState:

			if( *(iLine + iOffset) == '\0' || 

				*(iLine + iOffset) == '\r' || 

				*(iLine + iOffset) == '\n')

			{

				/*

				 * Skip empty lines.

				 */

				return false;

			}

			else

			{

				NextToken();

			}

			break;

		default:

			NextToken();

			break;

		}

	}

	return false;

}

/**

This function parses a line of the def file based on the current 

state it is in.

@internalComponent

@released

*/

void LineToken::NextToken()

{

	int aCurrentPos = 0;

	char *aSymbolName;

	switch( iState )

	{

	case EInitState:

		if(IsWhiteSpace((iLine + iOffset), aCurrentPos))

		{

			IncrOffset(aCurrentPos);

		}

		if(IsWord(iLine + iOffset, aCurrentPos))

		{

			SetState(ESymbolName);

		}

	break;

	case ESymbolName:

	{

		// Get the length of the symbol

		IsWord(iLine + iOffset, aCurrentPos);

		char *cmt = strchr(iLine + iOffset, ';');

		char *aAlias = strchr(iLine + iOffset, '=');

		if( aAlias && (!cmt || (aAlias < cmt)) )

		{

			int aAliasPos = aAlias - (iLine+ iOffset);

			//Check if alias name is also supplied, they should be separated 

			// by whitespace, i.e., SymbolName=AliasName is valid while, 

			// SymbolName =AliasName is invalid.

			if( aAliasPos > aCurrentPos)

			{

				char *aToken = (iLine + iOffset + aCurrentPos);

				throw DEFFileError(UNRECOGNIZEDTOKEN, iFileName, iLineNum, aToken);

			}

			aSymbolName = new char[aAliasPos+1];

			strncpy(aSymbolName, iLine + iOffset, aAliasPos);

			aSymbolName[aAliasPos] = '\0';

			char *aExportName = new char[aCurrentPos - aAliasPos + 1];

			strncpy(aExportName, aAlias +1, (aCurrentPos - aAliasPos));

			aExportName[(aCurrentPos - aAliasPos)] = '\0';

			iSymbol->ExportName(aExportName);

		}

		else

		{

			aSymbolName = new char[aCurrentPos+1];

			strncpy(aSymbolName, iLine+ iOffset, aCurrentPos);

			aSymbolName[aCurrentPos] = '\0';

		}

		iSymbol->SymbolName(aSymbolName);

		IncrOffset(aCurrentPos);

		if(IsWhiteSpace((iLine + iOffset), aCurrentPos))

		{

			IncrOffset(aCurrentPos);

		}

		if(*(iLine+iOffset) == '@')

		{

			SetState(EAtSymbol);

			IncrOffset(1);

		}

		else

		{

			/*

			 * The first non-whitespace entry in a line is assumed to be the 

			 * symbol name and a symbol name might also have a '@' char. Hence

			 * there MUST be a whitespace between symbol name and '@'.

			 */

			throw DEFFileError(ATRATEMISSING,iFileName,iLineNum,(iLine+iOffset));

		}

	}

	break;

	case EAtSymbol:

		if(IsWhiteSpace((iLine + iOffset), aCurrentPos))

		{

			IncrOffset(aCurrentPos);

		}