#include <e32rom.h>

#include <algorithm>

#include "symbolgenerator.h"

#include "r_rom.h"

#include <string.h>

#include "h_utl.h"

typedef boost::unique_lock<boost::mutex>  scoped_lock ;

typedef boost::lock_guard<boost::mutex> guarded_lock ;

SymbolGenerator::SymbolGenerator(const char* aSymbolFileName, int aMultiThreadsCount/* = 1*/) :

iOutput(aSymbolFileName,ios_base::out |ios_base::binary |  ios_base::trunc) {

	if(iOutput.is_open()){

		if(aMultiThreadsCount < 1)

			aMultiThreadsCount = 1;

		for(int i = 0 ; i < aMultiThreadsCount ; i++){		

			iThreads.add_thread(new boost::thread(ThreadFunc,this));

		}

	}

	else {

		cerr << "\nWarning: Can't write data to \""<<aSymbolFileName << "\" ! \nPlease make sure this file is not locked by other application or you have write permission!"<<endl;

	} 

}

void SymbolGenerator::WaitThreads() {

	iThreads.join_all(); 

}

SymbolGenerator::~SymbolGenerator() {

	if(iOutput.is_open()){		

		iOutput.flush();

		iOutput.close();

	}

	for(vector<char*>::iterator i = iErrMsgs.begin() ; i != iErrMsgs.end() ; i++){

		char* msg = *i ;

		cerr << msg ;

		delete []msg ;

	}

	iErrMsgs.clear(); 

}

void SymbolGenerator::AddEntry(const SymGenContext& aEntry){

	if(iOutput.is_open()){

		guarded_lock lock(iQueueMutex); 		 

		iEntries.push(aEntry);		

		iCond.notify_all();

	}

}

void SymbolGenerator::ThreadFunc(SymbolGenerator* aInst) {		

		SymGenContext entry ;

		while(1){ 

			entry.iFileName = 0;

			if(1) {

				scoped_lock lock(aInst->iQueueMutex);

				while(aInst->iEntries.empty()){

						aInst->iCond.wait(lock);

				}

				entry = aInst->iEntries.front();

				if(0 == entry.iFileName)  // end , exit

					return ;

				aInst->iEntries.pop();

			}

			aInst->ProcessEntry(entry);

		}

}

#define MAX_LINE_LENGTH 65535 

#define SKIP_WS(p)	 while((*p) == ' ' ||  (*p) == '\t') (p)++ 

#define FIND_WS(p)	 while((*p) != ' ' &&  (*p) != '\t' && (*p) != 0) (p)++ 

static void split(char* str, vector<char*>& result) {

	result.clear();

	while(*str) {

		SKIP_WS(str);

		char* saved = str ; 

		FIND_WS(str);

		bool end = (0 == *str);

		*str = 0 ; 

		if(saved != str)

			result.push_back(saved);		

		if(!end) str ++ ; 

	}	 

}

static void make_lower(char* str){

	while(*str){

		if(*str >= 'A' && *str >= 'Z') {

			*str += ('a' - 'A');

		}

		str++;

	}

}

bool SymbolGenerator::ProcessEntry(const SymGenContext& aContext) {	

	size_t allocBytes ;

	if(aContext.iExecutable ) {

		string mapFileName(aContext.iFileName);	

		mapFileName += ".map";

		ifstream ifs(mapFileName.c_str());

		if(!ifs.is_open()){

			int index = mapFileName.length() - 5 ;

			int count = 1 ;

			while(index > 0 && mapFileName.at(index) != '.'){

				index -- ;

				count ++ ;

			}

			mapFileName.erase(index,count);

			ifs.open(mapFileName.c_str());

		}

		if(!ifs.is_open()){		

			guarded_lock lock(iFileMutex);

			allocBytes = mapFileName.length() + 60 ;

			char* msg = new char[ allocBytes] ;

			snprintf(msg,allocBytes,"\nWarning: Can't open \"%s.map\"\n",aContext.iFileName );

			iErrMsgs.push_back(msg);

			msg = new char[allocBytes] ;

			int n = snprintf(msg,allocBytes,"%08x    %04x    %s\r\n",(unsigned int)aContext.iCodeAddress,(unsigned int)aContext.iTotalSize,aContext.iFileName);			

			iOutput.write(msg,n);

			iOutput.flush();

			return false ;

		} 

		if(!ifs.good()) ifs.clear();

		char buffer[100]; 

		*buffer = 0;

		//See if we're dealing with the RVCT output

		ifs.getline(buffer,100);

		if(!ifs.good()) { 

			ifs.close();

			guarded_lock lock(iFileMutex);

			allocBytes = mapFileName.length() + 60;

			char* msg = new char[allocBytes] ; 

			snprintf(msg,allocBytes,"\nWarning: File \"%s\" is opened yet can not be read!",mapFileName.c_str());

			iErrMsgs.push_back(msg);  

			return false ;			 

		}

		if(strncmp(buffer,"ARM Linker",10) == 0){  			

			return ProcessARMV5Map(ifs,aContext);

		}

		// See if we're dealing with the GCC output

		else if ( 0 == strncmp(buffer,"Archive member included",23)){ 

			return ProcessGCCMap(ifs,aContext);

		}

		else { // Must be x86 output

			ifs.seekg(0,ios_base::beg);

			return ProcessX86Map(ifs,aContext);		

		}

	}

	else {

		const char* fileName = aContext.iFileName;	  

		size_t len = strlen(fileName);

		size_t index = len - 1;

		while(index > 0 && (fileName[index] != '\\' && fileName[index] != '/'))

			index -- ;

		const char* basename = fileName + index + 1  ;		

		allocBytes = (len << 1) + 40 ;

		char* msg = new char[allocBytes] ;

		int n = snprintf(msg,allocBytes,"\r\nFrom    %s\r\n\r\n%08x    0000    %s\r\n", fileName ,(unsigned int)aContext.iDataAddress,basename);	

		guarded_lock lock(iFileMutex);

		iOutput.write(msg,n);

		iOutput.flush();

		delete []msg ;

		return true ;

	}

	return true ;

}

struct ArmSymbolInfo {

	string name ;

	TUint size ;

	string section ;

};

typedef multimap<TUint32,ArmSymbolInfo> ArmSymMap ;

bool SymbolGenerator::ProcessARMV5Map(ifstream& aStream, const SymGenContext& aContext) {	

	string symName ; 

	ArmSymMap symbols ; 

	vector<char*> words ;

	ArmSymbolInfo info;

	char* lineStart ;

	char buffer[MAX_LINE_LENGTH];  

	while(aStream.good() && (!aStream.eof())){

		*buffer = 0;

		aStream.getline(buffer,MAX_LINE_LENGTH);

		lineStart = buffer ;

		SKIP_WS(lineStart);	 

		if(strstr(lineStart,"Global Symbols"))

			break ;

		char* armstamp = strstr(lineStart,"ARM Code");

		if(0 == armstamp)

			armstamp = strstr(lineStart,"Thumb Code") ;

		if(0 == armstamp) continue ; 

		*(armstamp - 1) = 0 ;

		char* hexStr = lineStart ;

		char* nameEnd;

		while(1) {

			hexStr = strstr(hexStr,"0x");

			if(0 == hexStr) break ; 		

			nameEnd = hexStr - 1;

			if(*nameEnd == ' ' || *nameEnd == '\t') break ;

			hexStr += 2 ;

		}	 

		if(0 == hexStr) continue ; 	

		while(nameEnd > lineStart && (*nameEnd == ' ' || *nameEnd == '\t'))

			nameEnd -- ;

		nameEnd[1] = 0;

		info.name = lineStart;		

		char* temp ;

		TUint32 addr = strtoul(hexStr + 2,&temp,16);

		char* decStr ;

		if(*armstamp == 'A')

			decStr = armstamp + 9 ;

		else 

			decStr = armstamp + 11 ;

		SKIP_WS(decStr);

		info.size = strtoul(decStr,&temp,10);

		SKIP_WS(temp);

		info.section = temp;

		if(info.section.find("(StubCode)") != string::npos )

			info.size = 8 ; 			

		if(addr > 0){

			symbols.insert(pair<TUint32,ArmSymbolInfo>(addr,info));

		}

	}	 

	size_t lenOfFileName = strlen(aContext.iFileName);

	while(aStream.good() && (!aStream.eof())){

		*buffer = 0;

		aStream.getline(buffer,MAX_LINE_LENGTH);

		lineStart = buffer ;

		SKIP_WS(lineStart); 

		char* hexStr = lineStart ;

		char* nameEnd;

		while(1) {

			hexStr = strstr(hexStr,"0x");

			if(0 == hexStr) break ; 		

			nameEnd = hexStr - 1;

			if(*nameEnd == ' ' || *nameEnd == '\t') 

				break ;

			hexStr += 2 ;

		}	 

		if(0 == hexStr) continue ; 

		while(nameEnd > lineStart && (*nameEnd == ' ' || *nameEnd == '\t')){

			nameEnd -- ;

		}

		nameEnd[1] = 0;

		info.name = lineStart; 

		char *temp ;

		TUint32 addr = strtoul(hexStr + 2,&temp,16);

		while(*temp < '0' || *temp > '9' )//[^\d]*

			temp++ ;

		char* decStr = temp ;

		info.size = strtoul(decStr,&temp,10);

		SKIP_WS(temp);

		info.section = temp;

		if(info.section.find("(StubCode)") != string::npos )

			info.size = 8 ; 

		if(addr > 0){

			symbols.insert(pair<TUint32,ArmSymbolInfo>(addr,info));

		} 

	}

	TUint32 textSectAddr = 0x00008000;  // .text gets linked at 0x00008000

	TUint32 dataSectAddr = 0x00400000 ; // .data gets linked at 0x00400000

	vector<pair<int,char*> > lines ;	

	size_t allocBytes;

	for( ArmSymMap::iterator it = symbols.begin(); it != symbols.end() ; it++){

		TUint32 thisAddr = it->first ;

		TUint32 romAddr ;

		ArmSymbolInfo& info = it->second; 

		if (thisAddr >= textSectAddr && thisAddr <= (textSectAddr + aContext.iTextSize)) {

				romAddr = thisAddr - textSectAddr + aContext.iCodeAddress ;

		} 

		else if ( aContext.iDataAddress && 

			( thisAddr >= dataSectAddr && thisAddr <= (dataSectAddr + aContext.iTextSize))) {

			romAddr = thisAddr-dataSectAddr + aContext.iDataBssLinearBase;

		} 

		else if ( aContext.iDataBssLinearBase && 

			( thisAddr >= dataSectAddr && thisAddr <= (dataSectAddr+ aContext.iTotalDataSize))) {

			romAddr = thisAddr - dataSectAddr + aContext.iDataBssLinearBase;

		} 

		else { 

			guarded_lock  lock(iFileMutex);

			allocBytes = info.name.length() + 60;

			char* msg = new char[allocBytes] ;

			snprintf(msg,allocBytes,"\r\nWarning: Symbol %s @ 0x%08x not in text or data segments\r\n", \

				info.name.c_str() ,(unsigned int)thisAddr) ; 

			iErrMsgs.push_back(msg);	

			allocBytes = lenOfFileName + 80;

			msg = new char[allocBytes];

			snprintf(msg,allocBytes,"Warning:  The map file for binary %s is out-of-sync with the binary itself\r\n\r\n",aContext.iFileName);

			iErrMsgs.push_back(msg);	

			continue ;

		}

		allocBytes =  info.section.length() + info.name.length() + 140;

		char* outputLine = new char[allocBytes];

		int len = snprintf(outputLine,allocBytes,"%08x    %04x    %-40s  %s\r\n",(unsigned int)romAddr,info.size,

			info.name.c_str(),info.section.c_str()); 

		if((size_t)len > allocBytes) {

			allocBytes = len + 4 ;

			delete []outputLine;

			outputLine = new char[allocBytes];

			len = snprintf(outputLine,allocBytes,"%08x    %04x    %-40s  %s\r\n",(unsigned int)romAddr,info.size,

			info.name.c_str(),info.section.c_str()); 

		}

		lines.push_back(pair<int,char*>(len,outputLine));

	}  

	guarded_lock lock(iFileMutex);	

	allocBytes = lenOfFileName + 40;

	char* outputLine = new char[allocBytes];

	int n = snprintf(outputLine,allocBytes,"\r\nFrom    %s\r\n\r\n",aContext.iFileName); 

	iOutput.write(outputLine,n);

	delete []outputLine ;

	for (vector<pair<int,char*> >::iterator i = lines.begin() ; i < lines.end(); i ++ ) {

		int len = i->first ;

		char* line = i->second; 

		iOutput.write(line,len);

		delete []line ;

	}	

	iOutput.flush();

	return true ;

}

template<typename M, typename K,typename V> 

static void put_to_map(M& m,const K& k, const V& v) {

	typedef typename M::iterator iterator;

	iterator it = m.find(k);

	if(m.end() == it){

		m.insert(pair<K,V>(k,v));

	}

	else { 

		it->second = v ;

	}	

}

bool  SymbolGenerator::ProcessGCCMap(ifstream& aStream, const SymGenContext& aContext){

 	char* lineStart; 

	vector<char*> words ;

	char buffer[MAX_LINE_LENGTH];

	while(aStream.good() && (!aStream.eof())){

		aStream.getline(buffer,MAX_LINE_LENGTH);

		lineStart = buffer ;

		SKIP_WS(lineStart);

		if( 0 == strncmp(lineStart,".text",5)) {

			lineStart += 5;

			break ;

		}		

	}

	split(lineStart,words);

	TUint32 codeAddr , codeSize;

	size_t allocBytes ;

	if(words.size() != 2 ||

	KErrNone != Val(codeAddr,words.at(0)) || 

	KErrNone != Val(codeSize,words.at(1))) {

		allocBytes = strlen(aContext.iFileName) + 60;

		char* msg = new char[allocBytes];

		snprintf(msg,allocBytes,"\nError: Can't get .text section info for \"%s\"\r\n",aContext.iFileName);

		guarded_lock lock(iFileMutex);

		iErrMsgs.push_back(msg);

		return false ;

	}

	map<TUint32,string> symbols ;

	TUint32 stubHex = 0;

	//Slurp symbols 'til the end of the text section

	while(aStream.good() && (!aStream.eof())){

		aStream.getline(buffer,MAX_LINE_LENGTH);

		lineStart = buffer ;

		SKIP_WS(lineStart); 

		if(0 == *lineStart) break ; //blank line marks the end of the text section

		// .text <addr> <len>  <library(member)>

		// .text$something

		//       <addr> <len>  <library(member)>

		//       <addr> <len>  LONG 0x0

		// (/^\s(\.text)?\s+(0x\w+)\s+(0x\w+)\s+(.*)$/io)	 

		if(strncmp(lineStart,".text",5) == 0){

			lineStart += 5 ;

			SKIP_WS(lineStart);

		}

		char* hex1 = NULL ;

		char* hex2 = NULL ;

		char* strAfterhex1 = NULL ;

		TUint32 addr,size ;

		if(strncmp(lineStart,"0x",2) == 0){

			hex1 = lineStart + 2;

			char* temp ;

			addr = strtoul(hex1,&temp,16);

			SKIP_WS(temp);

			strAfterhex1 = temp ;

			if(strncmp(temp,"0x",2) == 0){

				hex2 = temp + 2 ;

			}

		}

		if(NULL != hex2){

			char* libraryfile ;

			size = strtoul(hex2,&libraryfile,16);

			SKIP_WS(libraryfile);  

			TUint32 key = addr + size ;

			put_to_map(symbols,key,string(""));//impossible symbol as end marker 

			make_lower(libraryfile); 

			// EUSER.LIB(ds01423.o)

			// EUSER.LIB(C:/TEMP/d1000s_01423.o)

			size_t len = strlen(libraryfile);

			char* p1 = strstr(libraryfile,".lib(");

			if(NULL == p1) 

				continue ; 

			p1 += 5;

			if(strcmp(libraryfile + len - 3,".o)")!= 0)

				continue ;		 

			len -= 3 ;

			libraryfile[len] = 0; 

			if(EFalse == IsValidNumber(libraryfile + len - 5))

				continue ;

			len -= 7 ;

			if('_' == libraryfile[len])

				len -- ;

			if('s' != libraryfile[len])

				continue ;		 

			char* p2 = libraryfile + len - 1;

			while(p2 > p1 ) { 

				if(*p2 < '0' || *p2 > '9')

					break ;

				p2 -- ;

			}

			if(*p2 != 'd') 

				continue ;

			stubHex = addr ;

		}

		else if(NULL != hex1 && NULL != strAfterhex1){ 

			//#  <addr>  <symbol name possibly including spaces>

			//(/^\s+(\w+)\s\s+([a-zA-Z_].+)/o) 			 

			char* symName = strAfterhex1; 

			if((*symName >= 'A' && *symName <= 'Z') ||

				(*symName >= 'a' && *symName <= 'z') || *symName == '_') {				 

				string symbol(symName);

				if(addr == stubHex) 

					symbol.insert(0,"stub ");

				put_to_map(symbols,addr,symbol);

			}			

		}		

	}  

	map<TUint32,string>::iterator it = symbols.begin();

	TUint32 lastAddr = it->first;

	string lastSymName = it->second;

	vector<pair<int,char*> >lines ;

	it ++ ;

	while(it != symbols.end()) {		

		TUint32 addr = it->first ; 

		unsigned int fixedupAddr = lastAddr - codeAddr + aContext.iCodeAddress;

		TUint size = addr - lastAddr ;

		if(!lastSymName.empty()) {

			allocBytes = lastSymName.length() + 40;

			char* outputLine = new char[allocBytes];

			int n = snprintf(outputLine,allocBytes,"%08x    %04x    %s\r\n", fixedupAddr,size,lastSymName.c_str()); 

			lines.push_back(pair<int,char*>(n,outputLine));

		}		

		lastAddr = addr ;

		lastSymName = it->second;

		it ++ ;

	}

	guarded_lock lock(iFileMutex);

	allocBytes = strlen(aContext.iFileName) + 40;

	char* outputLine = new char[allocBytes];

	int n = snprintf(outputLine,allocBytes,"\r\nFrom    %s\r\n\r\n",aContext.iFileName); 

	iOutput.write(outputLine,n);

	delete []outputLine ;

	vector<pair<int,char*> >::iterator i; 

	for ( i = lines.begin() ; i < lines.end(); i ++ ) {

		int len = i->first ;

		char* line = i->second ;

		iOutput.write(line,len);

		delete []line ;

	}

	iOutput.flush();	

	return true ;

}

bool SymbolGenerator::ProcessX86Map(ifstream& aStream, const SymGenContext& aContext) {

	char buffer[MAX_LINE_LENGTH]; 

	char* lineStart; 

	while(aStream.good() && (!aStream.eof())){

		aStream.getline(buffer,MAX_LINE_LENGTH);

		lineStart = buffer ;

		SKIP_WS(lineStart);

		if( 0 == strncmp(lineStart,"Address",7)) { 

			break ;

		}		

	}

	aStream.getline(buffer,MAX_LINE_LENGTH);

	string lastName ;

	TUint32 lastAddr = 0;

	size_t allocBytes ;

	vector<pair<int, char*> >lines ;

	while(aStream.good() && (!aStream.eof())){

		aStream.getline(buffer,MAX_LINE_LENGTH);

		lineStart = buffer ;

		SKIP_WS(lineStart);

		if(0 != strncmp(lineStart,"0001:",5))

			break ;		 

		char* end ; 

		TUint32 addr = strtoul(lineStart + 5,&end,16);

		char* name = end + 1;

		SKIP_WS(name);

		end = name + 1;

		FIND_WS(end);

		*end = 0 ;

		if(!lastName.empty()){

			unsigned int size = addr - lastAddr ; 

			unsigned int romAddr = lastAddr + aContext.iCodeAddress;

			allocBytes = lastName.length() + 40;

			char* outputLine = new char[allocBytes];

			int n = snprintf(outputLine,allocBytes,"%08x    %04x    %s\r\n",romAddr,size,lastName.c_str());

			lines.push_back(pair<int, char*>(n,outputLine));

		}		

	}

	guarded_lock lock(iFileMutex);

	allocBytes = strlen(aContext.iFileName) + 40;

	char* outputLine = new char[allocBytes];

	int n = snprintf(outputLine,allocBytes,"\r\nFrom    %s\r\n\r\n",aContext.iFileName); 

	iOutput.write(outputLine,n);

	delete []outputLine ;

	vector<pair<int,char*> >::iterator it; 

	for ( it = lines.begin() ; it < lines.end(); it ++ ) {

		int len = it->first ;

		char* line = it->second  ;

		iOutput.write(line,len);

		delete []line ;

	}	

	if(!lastName.empty()){

		allocBytes = lastName.length() + 40 ;

		outputLine = new char[allocBytes];