// 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;
	}