/*

* Copyright (c) 1998-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: 

* e32tools/rombuild/r_dir.cpp

*

*/

#include <stdlib.h>

#include <string.h>

#include "r_dir.h"

#include "r_obey.h"

#include "r_rom.h"

#include "r_global.h"

// Generalised set handling

// class SetMember

TInt SetMember::TotalInSystem=0;

SetMember::~SetMember()

	{

	TotalInSystem--;

	TRACE(TDIR,Print(EAlways,"SetMember %08x Destruct Remaining=%d\n",this,TotalInSystem));

	}

void SetMember::Close()

	{

	delete this;

	}

// class FiniteSet

FiniteSet::FiniteSet(TInt aMaxCount)

	: SetMember(EFiniteSetType), iMaxCount(aMaxCount), iCount(0), iMembers(NULL)

	{}

FiniteSet::FiniteSet(const FiniteSet& aSet)

	: SetMember(aSet), iMaxCount(aSet.iMaxCount), iCount(0), iMembers(NULL)

	{}

FiniteSet* FiniteSet::New(TInt aMaxCount)

	{

	FiniteSet* pS=new FiniteSet(aMaxCount);

	if (pS)

		pS=pS->Construct();

	return pS;

	}

FiniteSet* FiniteSet::Construct()

	{

	SetMember** pM=new SetMember*[iMaxCount];

	if (!pM)

		{

		delete this;

		return NULL;

		}

	iMembers=pM;

	TInt i;

	for(i=0; i<iMaxCount; i++)

		pM[i]=NULL;

	return this;

	}

FiniteSet* FiniteSet::Singleton(TInt aMaxCount, const SetMember& aMember)

	{

	FiniteSet* pS=New(aMaxCount);

	if (pS)

		{

		pS->iCount=1;

		pS->iMembers[0]=(SetMember*)&aMember;

		}

	return pS;

	}

FiniteSet::~FiniteSet()

	{

	TRACE(TDIR,Print(EAlways,"FiniteSet %08x Destruct, iCount=%d\n",this,iCount));

	TInt i;

	for (i=0; i<iCount; i++)

		iMembers[i]->Close();

	delete[] iMembers;

	}

TInt FiniteSet::Find(const SetMember& aMember, TInt& anIndex) const

	{

	if (iCount==0)

		{

		anIndex=0;

		return KErrNotFound;

		}

	TInt k=aMember.Compare(*iMembers[0]);

	if (k==0)

		{

		anIndex=0;

		return KErrNone;

		}

	if (k<0)

		{

		anIndex=0;

		return KErrNotFound;

		}

	if (iCount==1)

		{

		anIndex=1;

		return KErrNotFound;

		}

	TInt r=iCount-1;

	k=aMember.Compare(*iMembers[r]);

	if (k==0)

		{

		anIndex=r;

		return KErrNone;

		}

	if (k>0)

		{

		anIndex=iCount;

		return KErrNotFound;

		}

	if (iCount==2)

		{

		anIndex=1;

		return KErrNotFound;

		}

	TInt l=0;

	while(r-l>1)

		{

		TInt m=(l+r)>>1;

		k=aMember.Compare(*iMembers[m]);

		if (k==0)

			{

			anIndex=m;

			return KErrNone;

			}

		if (k>0)

			l=m;

		else

			r=m;

		}

	anIndex=r;

	return KErrNotFound;

	}

TInt FiniteSet::Compare(const SetMember& aSetMember) const

	{

	TInt k=Type()-aSetMember.Type();

	if (k!=0)

		return k;

	const FiniteSet& s=(const FiniteSet&)aSetMember;

	TInt c=Min(iCount,s.iCount);

	TInt i;

	for(i=0; i<c; i++)

		{

		k=iMembers[i]->Compare(s[i]);

		if (k!=0)

			return k;

		}

	return (iCount-s.iCount);

	}

SetMember* FiniteSet::Copy() const

	{

	FiniteSet* pS=new FiniteSet(*this);

	if (pS)

		{

		SetMember** pA=new SetMember*[iMaxCount];

		if (!pA)

			{

			delete pS;

			return NULL;

			}

		pS->iMembers=pA;

		TInt i;

		for(i=0; i<iCount; i++)

			{

			SetMember* pM=iMembers[i]->Copy();

			if (!pM)

				{

				delete pS;

				return NULL;

				}

			pA[i]=pM;

			pS->iCount++;

			}

		}

	return pS;

	}

TInt FiniteSet::Find(const SetMember& aMember) const

	{

	TInt i;

	TInt r=Find(aMember,i);

	if (r<0)

		return r;

	return i;

	}

TBool FiniteSet::SubsetOf(const FiniteSet& aSet) const

	{

	if (iCount>aSet.iCount)

		return EFalse;

	TInt i;

	for(i=0; i<iCount; i++)

		{

		TInt j;

		if (aSet.Find(*iMembers[i],j)!=KErrNone)

			return EFalse;

		}

	return ETrue;

	}

TInt FiniteSet::Intersection(const FiniteSet& aSet)

	{

	if (iCount==0)

		return KErrNotFound;

	TInt i;

	for(i=0; i<iCount; i++)

		{

		TInt j;

		if (aSet.Find(*iMembers[i],j)!=KErrNone)

			Detach(i)->Close();

		}

	return iCount ? KErrNone : KErrNotFound;

	}

TInt FiniteSet::Union(const FiniteSet& aSet)

	{

	TInt i;

	for(i=0; i<aSet.iCount; i++)

		{

		const SetMember& m=*aSet.iMembers[i];

		TInt j;

		if (Find(m,j)!=KErrNone)

			{

			const SetMember* pC=m.Copy();

			if (!pC)

				return KErrNoMemory;

			TInt r=Insert(*pC,j);

			if (r!=KErrNone)

				return r;

			}

		}

	return iCount ? KErrNone : KErrNotFound;

	}

TInt FiniteSet::Difference(const FiniteSet& aSet)

	{

	if (iCount==0)

		return KErrNotFound;

	TInt i;

	for(i=0; i<iCount; i++)

		{

		TInt j;

		if (aSet.Find(*iMembers[i],j)==KErrNone)

			Detach(i)->Close();

		}

	return iCount ? KErrNone : KErrNotFound;

	}

TInt FiniteSet::Add(const SetMember& aMember)

	{

	TInt i;

	TInt r=Find(aMember,i);

	if (r==KErrNotFound && Insert(aMember,i)==KErrOverflow)

		return KErrOverflow;

	return r;

	}

TInt FiniteSet::Remove(const SetMember& aMember)

	{

	TInt i;

	TInt r=Find(aMember,i);

	if (r==KErrNone)

		Detach(i)->Close();

	return r;

	}

SetMember* FiniteSet::Detach(TInt anIndex)

	{

	TInt i;

	SetMember* pM=iMembers[anIndex];

	for(i=anIndex; i<iCount-1; i++)

		iMembers[i]=iMembers[i+1];

	iCount--;

	return pM;

	}

TInt FiniteSet::Insert(const SetMember& aMember, TInt anIndex)

	{

	if (iCount==iMaxCount)

		return KErrOverflow;

	TInt i;

	for(i=iCount-1; i>=anIndex; i--)

		iMembers[i+1]=iMembers[i];

	iMembers[anIndex]=(SetMember*)&aMember;

	iCount++;

	return KErrNone;

	}

// ROMBUILD-specific stuff

inline TLinAddr ActualToRomAddress(TAny* anAddr)

	{ return TLinAddr(anAddr)-TheRomMem+TheRomLinearAddress; }

// class TVariantList

TInt TVariantList::NumVariants;

THardwareVariant TVariantList::Variants[TVariantList::EMaxVariants];

void TVariantList::Setup(CObeyFile* aObey)

	{

	NumVariants=aObey->iNumberOfVariants;

	if (NumVariants>EMaxVariants)

		Print(EError,"Too many variants");

	TInt i;

	for(i=0; i<NumVariants; i++)

		{

		Variants[i]=aObey->iVariants[i]->iHardwareVariant;

		}

	}

TVariantList::TVariantList(THardwareVariant a)

	{

	iList=0;

	TInt i;

	for (i=0; i<NumVariants; i++)

		{

		if (Variants[i]<=a)

			iList|=TUint(1<<i);

		}

	}

THardwareVariant TVariantList::Lookup() const

	{

	TInt i;

	for (i=0; i<NumVariants; i++)

		{

		if (iList & TUint(1<<i))

			return Variants[i];

		}

	return THardwareVariant(0);

	}

void TVariantList::SetNumVariants(TInt aNumVariants)

{

	NumVariants = aNumVariants;

	if (NumVariants>EMaxVariants)

		Print(EError,"Too many variants");

}

void TVariantList::SetVariants(THardwareVariant* aVariants)

{

	TInt Index = NumVariants;

	while(Index--)

	{

		Variants[Index] = aVariants[Index];

	}

}

void DumpRomEntry(const TRomEntry& e)

	{

	char name[256];

	char* d = name;

	const wchar_t* s = (const wchar_t*)e.iName;

	const wchar_t* sE = s + e.iNameLength;

	for (; s<sE; *d++ = (char)*s++) {}

	*d++ = 0;

	Print(ELog, "RomEntry @ %08x: SZ=%08x A=%08x att=%02x name %s\n", &e, e.iSize, e.iAddressLin, e.iAtt, name);

	}

// class Entry

TRomEntry* Entry::CreateRomEntry(char*& anAddr) const

	{

	TRomEntry *pE=(TRomEntry*)anAddr;

	pE->iAtt=iRomNode->iAtt;

	pE->iSize=iRomNode->iRomFile->iAddresses.iSize;

	pE->iAddressLin=iRomNode->iRomFile->iAddresses.iRunAddr;

	if (IsFile())

		iRomNode->iRomFile->SetRomEntry(pE);

	pE->iName[0]=0;

	pE->iName[1]=0;

	TInt nl=iRomNode->NameCpy((char*)pE->iName);

	pE->iNameLength=(TUint8)nl;

	if (Unicode)

		nl<<=1;

	anAddr+=Align4(KRomEntrySize+nl);

	TRACE(TDIR,DumpRomEntry(*pE));

	return pE;

	}

const TText* Entry::Name() const

	{

	return iRomNode->iName;

	}

// class FileEntry

FileEntry::FileEntry(const FileEntry& aFileEntry)

	: Entry(aFileEntry)

	{

	iVariants=aFileEntry.iVariants;

	iRomNode=aFileEntry.iRomNode;

	}

FileEntry* FileEntry::New(TRomNode* aFile)

	{

	FileEntry* pE=new FileEntry();

	if (pE)

		{

		pE->iRomNode=aFile;

		pE->iVariants=TVariantList(aFile->HardwareVariant());

		}

	return pE;

	}

TInt FileEntry::Compare(const SetMember& aMember) const

	{

	TInt k=Type()-aMember.Type();

	if (k!=0)

		return k;

	FileEntry *entry=(FileEntry *)&aMember;

	return (iRomNode->iIdentifier-entry->iRomNode->iIdentifier);

	}

SetMember* FileEntry::Copy() const

	{

	return new FileEntry(*this);

	}

FileEntry::~FileEntry()

	{

	}

// class DirEntry

DirEntry::DirEntry(const DirEntry& aDirEntry)

	: Entry(aDirEntry)

	{

	iVariants=aDirEntry.iVariants;

	iRomNode=aDirEntry.iRomNode;

	iDir=aDirEntry.iDir;

	}

DirEntry* DirEntry::New(TRomNode* aFile, Directory* aDir)

	{

	DirEntry* pE=new DirEntry();

	if (pE)

		{

		pE->iRomNode=aFile;

		pE->iVariants=aDir->iVariants;

		pE->iDir=aDir;

		if (aDir)

			aDir->Open();

		}

	return pE;

	}

TInt DirEntry::Compare(const SetMember& aMember) const

	{

	TInt k=Type()-aMember.Type();

	if (k!=0)

		return k;

	DirEntry *entry=(DirEntry *)&aMember;

	return (iDir->iIdentifier - entry->iDir->iIdentifier);

	}

SetMember* DirEntry::Copy() const

	{

	DirEntry* pE=new DirEntry(*this);

	if (pE && pE->iDir)

		pE->iDir->Open();

	return pE;

	}

DirEntry::~DirEntry()

	{

	if (iDir)

		iDir->Close();

	}

// data structure and function for qsort

struct SortableEntry 

	{

	unsigned int iOffset;

	Entry* iEntry;

	};

int compare(const void* left, const void* right)

	{

	const SortableEntry* le  = (const SortableEntry*)left;

	const SortableEntry* re = (const SortableEntry*)right;

	if (le->iEntry->IsDir())

		{

		if (!re->iEntry->IsDir())

			return -1;	// dir < file

		}

	else

		{

		if (re->iEntry->IsDir())

			return +1;	// file > dir

		}

	// Both the same type of entry, sort by name.

	// Sorting the 8-bit data using ASCII folding matches the sort order in terms of 16 bit

	// characters provided that 8-bit data is actually CESU-8 rather than UTF-8. The two

	// formats differ only when using surrogates (ie unicode values >= 0x10000). UTF-8 encodes

	// an entire 32 bit value as a sequence of up to 6 bytes whereas CESU-8 encodes UTF-16

	// values independently.

	const char* l = (const char*)le->iEntry->Name();

	const char* r = (const char*)re->iEntry->Name();

	int result, lc, rc;

	do	{

		lc = *l++;

		rc = *r++;

		if (lc >= 'A' && lc <= 'Z')

			lc += ('a' - 'A');

		if (rc >= 'A' && rc <= 'Z')

			rc += ('a' - 'A');

		result = lc - rc;

		} while (lc && result==0);

	return result;

	}