// Copyright (c) 2000-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 "analyse.h"

 #include "symbols.h"

 #ifdef __MSVCDOTNET__

 #include <fstream>

 #else //!__MSVCDOTNET__

 #include <fstream.h>

 #endif //__MSVCDOTNET__

 namespace {

 unsigned ParseHex(const char* aText, int aLength)

 	{

 	unsigned value = 0;

 	const char* end = aText + aLength;

 	do

 		{

 		unsigned c = *aText++ - '0';

 		if (c > 9)

 			c -= 'a' - '0' - 10;

 		value = (value << 4) + c;

 		} while (aText < end);

 	return value;

 	}

 };

 // class SymbolFile

 SymbolFile::SymbolFile(const char* aSymbolFile, bool aRofs)

 	:iText(0), iTextLower(0)

 	{

 	ifstream file;

 #ifdef __MSVCDOTNET__

 	file.open(aSymbolFile, ios::binary);

 #else //!__MSVCDOTNET__

 	file.open(aSymbolFile, ios::nocreate | ios::binary);

 #endif //__MSVCDOTNET__

 	if (!file)

 		{

 		cerr << "Unable to open ROM symbol file '" << aSymbolFile << '\'' << endl;

 		Analyse::Abort();

 		}

 //

 	file.seekg(0, ios::end);

 	iLength = file.tellg();

 //

 	iText = new char[iLength+1];

 	file.seekg(0, ios::beg);

 	file.read(iText, iLength);

 	iText[iLength] = '\0';

 //

 	file.close();

 	if (aRofs)

 		{

 		iTextLower = new char[iLength+1];

 		for(char *p = iTextLower, *c = iText, *end = iText + iLength;c < end;c++, p++) 

 			*p = tolower(*c);

 		}

 	}

 SymbolFile::~SymbolFile()

 	{

 	delete [] iText;

 	if (iTextLower)

 		delete [] iTextLower;

 	}

 bool SymbolFile::Parse(SymbolFile::Parser& aParser, const char* aModuleName, PC aAddress, PC aModuleLength, int aModuleId) const

 	{

 	char* text = 0;

 	PC first_pc_limit = 0, last_pc_limit = 0;

 	TState state = EPreFile;

 	PC lastPC = 0;

 	bool inSyms = false;

 	const char *prevName = 0;

 	int lastLen = 0;

 	if (aModuleName) // should parse only one module 

 		{

 		bool not_found = false;

 		char * name = strstr(iTextLower, aModuleName);

 		if (name)

 			{

 			for(char * p = name; p != iTextLower && *p != '\n';p--);

 			if (*p == '\n' || p == iTextLower) 

 				{

 				name = ++p;

 				text = iText + (name - iTextLower);

 				}

 			else

 				not_found = true;

 			}

 		else

 			not_found = true;

 		if (not_found)

 			return false;

 		state = EFile;

 		}

 	else

 		text = iText;

 	const char* end = iText + iLength;

 	while (text < end && state != EError)

 		{

 		char* endl = strchr(text, '\r');

 		if (endl == 0)

 			{

 			if (!aModuleName)

 				{

 				state = EError;

 				break;

 				}

 			else

 				{

 				char* p = text + strlen(text);

 				if (*(p+1) == '\n')

 					endl = p;

 				else

 					{

 					state = EError;

 					break;

 					}

 				}

 			}

 		switch (state)

 			{

 		case EPreFile:

 			if (endl != text)

 				state = EError;

 			else

 				state = EFile;

 			break;

 		case EFile:

 			if (strncmp(text, "From", 4) != 0)

 				state = EError;

 			else

 				{

 				*endl = '\0';

 				char* name = strrchr(text, '\\');

 				if (name == 0)

 					name = text + 8;

 				else

 					++name;

 				aParser.File(name);

 				state = EPostFile;

 				}

 			break;

 		case EPostFile:

 			if (endl != text)

 				state = EError;

 			else

 				state = ESymbol;

 			break;

 		case ESymbol:

 			if (text == endl)

 				{

 				if (aModuleName)

 					goto Quit; 

 				else

 					state = EFile;

 				}

 			else

 				{

 				PC pc = ParseHex(text, 8);

 				pc &= ~1; // should be odd address, error in symbol table

 				if(aModuleName)

 					pc += aAddress;

 				*endl = '\0';

 				char* codeType = strrchr(text+20, '(');

 				if ( codeType == NULL || (strcmp(codeType,"(.data)") != 0 &&

 					 strcmp(codeType,"(.bss)") != 0 &&

 					 strcmp(codeType,"(.init_array)") != 0 &&

 					 strcmp(codeType,"(linker$$defined$$symbols)") != 0 &&

 					 strcmp(codeType,"(ExportTable)") != 0) )

 					{

 					if(inSyms && (pc > (lastPC + lastLen)))

 						{

 						memcpy((void *)(prevName - 15), "<static> after ", 15);

 						aParser.Symbol(prevName - 15, lastPC + lastLen, pc - (lastPC + lastLen));

 						}

 					int length = ParseHex(text + 12, 4);

 					if(pc >= lastPC + lastLen)

 						{

 						bool is_added = aParser.Symbol(text + 20, pc, length);

 						if (is_added && aModuleName && !first_pc_limit) 

 							{

 							first_pc_limit = pc + length;

 							last_pc_limit = pc + aModuleLength;

 							}

 						}

 					prevName = text + 20;

 					if(pc + length > lastPC + lastLen)

 						{

 						lastLen = length;

 						lastPC = pc;

 						}

 					inSyms = true;

 					}

 				}

 			break;

 		case EError:

 			break;

 			}

 		text = endl + 2;

 		}

 	if (state == EError)

 		Analyse::Abort("Bad ROM symbol file format");

 Quit:

 	if(aModuleName && lastPC == first_pc_limit && (lastPC + lastLen) < last_pc_limit)

 		{

 		memcpy((void *)(prevName - 10), "<anon> in ", 10);

 		aParser.Symbol(prevName - 10, lastPC + lastLen, last_pc_limit - (lastPC + lastLen));

 		}

 	aParser.Done(first_pc_limit, last_pc_limit, aModuleId);

 	return true;

 	}