// 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 <crtdbg.h>
#include "analyse.h"
#include "codespace.h"

#ifdef __MSVCDOTNET__
#pragma warning(push, 3)	// cannot compile MSVC's STL at warning level 4
#pragma warning(disable: 4786 4710 4530)
#include <strstream>
#include <iomanip>
#else //!__MSVCDOTNET__
#include <strstrea.h>
#include <iomanip.h>
#endif //__MSVCDOTNET__

#include <algorithm>

// class CodeSpace

int CodeSpace::Size() const
	{
	return 1;
	}

int CodeSpace::Bucket(PC) const
	{
	return KOtherBucket;
	}

const char* CodeSpace::Name(int) const
	{
	return "<other>";
	}

CodeSpace::TOrder CodeSpace::Ordering() const
	{
	return ERandom;
	}


// class AddressCodeSpace

AddressCodeSpace::AddressCodeSpace(PC aBase, PC aLimit, unsigned aBucketSize, TType aType)
	:iBase(aBase), iType(aType)
	{
	if (aBucketSize < 1)
		aBucketSize = 1;
	unsigned shift;
	for (shift = 0; (aBucketSize >> shift) != 1; ++shift)
		;
	iBucketShift = shift;
	iBuckets = (aLimit - aBase + (1u << shift) - 1) >> shift;
	}

int AddressCodeSpace::Size() const
	{
	return iBuckets + 1;
	}

int AddressCodeSpace::Bucket(PC aPc) const
	{
	if (aPc >= iBase)
		{
		unsigned bucket = (aPc - iBase) >> iBucketShift;
		if (bucket < iBuckets)
			return bucket + 1;
		}
	return KOtherBucket;
	}

const char* AddressCodeSpace::Name(int aBucket) const
	{
	if (aBucket == KOtherBucket)
		return CodeSpace::Name(aBucket);

	unsigned offset = ((aBucket - 1) << iBucketShift);
	strstream s(iBuffer, sizeof(iBuffer), ios::out);
	s << hex << setfill('0');
	if (iType == EAbsolute)
		s << setw(8) << iBase + offset;
	else
		s << "+ " << setw(4) << offset;
	s << setfill(' ') << '\0';
	return iBuffer;
	}

CodeSpace::TOrder AddressCodeSpace::Ordering() const
	{
	return (iType == EAbsolute) ? EOrdered : ELinear;
	}


// class MappedCodeSpace

MappedCodeSpace::MappedCodeSpace(const SymbolFile& aSymbols, MappedCodeSpace::Partition& aPartition)
	{
	aPartition.iCodeSpace = this;
	aSymbols.Parse(aPartition);
	}

MappedCodeSpace::MappedCodeSpace() 
	{}

const MappedCodeSpace::Element* MappedCodeSpace::Find(PC aPc) const
//
// Find and return the element which contains this PC value
// If not mapped return 0
//
	{
	Map::const_iterator e = iMap.upper_bound(aPc);

	// ignore deleted segments
	for(;e != iMap.end() && aPc >= e->second.iBase;e++)
		if (!e->second.iUnloaded)
			return &e->second;
	return 0;
	}

std::pair<const char*,unsigned> MappedCodeSpace::Lookup(PC aPc) const
	{
	const Element* e = Find(aPc);
	if (e == 0)
		return std::pair<const char*,unsigned>(0, aPc);
	return std::pair<const char*,unsigned>(e->iName, aPc - e->iBase);
	}

int MappedCodeSpace::Size() const
	{
	return iMap.size() + 1;
	}

int MappedCodeSpace::Bucket(PC aPc) const
	{
	const Element* e = Find(aPc);
	return (e == 0) ? KOtherBucket : e->iBucket + 1;
	}

const char* MappedCodeSpace::Name(int aBucket) const
	{
	return (aBucket == KOtherBucket) ? CodeSpace::Name(aBucket) : iNames[aBucket - 1];
	}

void MappedCodeSpace::Add(PC aBase, PC aLimit, const char* aName)
	{
	// insert
	iMap.insert(Map::value_type(aLimit, Element(aBase, aLimit, aName)));
	}

void MappedCodeSpace::Done(PC aFirstPc, PC aLastPc, int aModuleId)
	{
	if (!aFirstPc)
		{
		iNames.clear();
		for (Map::iterator p = iMap.begin(), e = iMap.end(); p != e; ++p)
			{
			p->second.iBucket = iNames.size();
			iNames.push_back(p->second.iName);
			}
		}
	else
		{
		Map::iterator p = iMap.find(aFirstPc);
		_ASSERT(p != iMap.end());
		for (Map::iterator e = iMap.end(); p != e && p->first <= aLastPc; ++p)
			{
			if (p->second.iUnloaded) 
				continue;

			bool bFound = false;
			NamesMap::iterator pMap = iNamesMap.find(p->second.iName);
			if (pMap != iNamesMap.end())
				for(;!strcmp(p->second.iName, pMap->first);pMap++)
					if (pMap->second.iId == aModuleId)
						{
						bFound = true;
						break;
						}
			if (bFound)
				p->second.iBucket = pMap->second.iIndex;
			else
				{
				p->second.iBucket = iNames.size();
				iNames.push_back(p->second.iName);
				iNamesMap.insert(NamesMap::value_type(p->second.iName, IdNames(aModuleId, p->second.iBucket)));
				}
			}
		}
	}