// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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 <s32ucmp.h>

#include "BADICTIONARYCOMPRESSION.H"

#include "BaRscImpl.h"

#include "BaAssert.h"

#include "BaCompileAssert.h"

/** TCleanupItem function.

@internalComponent

@param aFile Pointer to the RFile instance which has to be closed. */

LOCAL_C void CloseAndDeleteFile(TAny* aFile)

	{

	RFile* const file=STATIC_CAST(RFile*,aFile);

	if (file!=NULL)

		{

		file->Close();

		delete file;

		}

	}

/** TCleanupItem function.

@internalComponent

@param aArrayOfDictionaryCompressionBitStreams Pointer to an array (RArray) of 

RDictionaryCompressionBitStream objects which have to be closed. */

LOCAL_C void CloseArrayOfDictionaryCompressionBitStreams(TAny* aArray)

	{

	typedef RArray<RDictionaryCompressionBitStream> RDictComprBitStream;

	RDictComprBitStream* array = static_cast <RDictComprBitStream*> (aArray);

	for (TInt i=array->Count()-1;i>=0;--i)

		{

		array[i].Close();

		}

	array->Close();

	}

/** @internalComponent */

struct SDictionaryCompressionData

	{

 	inline SDictionaryCompressionData() :

		iStartOfDictionaryData(0),

		iStartOfDictionaryIndex(0),

		iNumberOfDictionaryEntries(0),

		iStartOfResourceData(0),

		iStartOfResourceIndex(0),

		iNumberOfBitsUsedForDictionaryTokens(0), 

		iCachedDictionaryIndex(0),

		iCachedResourceBuffer(0)// = NULL;

		{

		}

	TInt iStartOfDictionaryData;

	TInt iStartOfDictionaryIndex;

	TInt iNumberOfDictionaryEntries;

	TInt iStartOfResourceData;

	TInt iStartOfResourceIndex;

	TInt iNumberOfBitsUsedForDictionaryTokens;

	TUint16* iCachedDictionaryIndex;

	TUint8* iCachedResourceBuffer;

	};

/** @internalComponent */

class RResourceFileImpl::TExtra

	{

public:

	TExtra(const TBaAssert& aAssertObj);

	~TExtra();

	TBool ContainsCompressedUnicodeL(TInt aRscIdx, TBool aFirstRscIsGen) const;

private:

	TExtra(const TExtra&);//prevent default copy constructor

	TExtra& operator=(const TExtra&);//prevent default "=" operator

public:

	TUidType iUidType;

	HBufC8* iBitArrayOfResourcesContainingCompressedUnicode; // an array of bits, one for each resource in the resource file

	SDictionaryCompressionData iDictionaryCompressionData;

	TInt iFileOffset;	// offset of RSC chunk in new AIF file format

	TBaAssert iAssertObj;

	TInt iFileSize;		// RSC chunc size - in new AIF file format, file size otherwise

	};

/** @internalComponent

@param aAssertObj Object which will determine RResourceFileImpl::TExtra

instance's behaviour if something goes wrong - depending on aAssertObj state

RResourceFileImpl::TExtra methods will leave or panic. */

RResourceFileImpl::TExtra::TExtra(const TBaAssert& aAssertObj) :

	iUidType(),

	iBitArrayOfResourcesContainingCompressedUnicode(NULL),

	iDictionaryCompressionData(),

	iFileOffset(0),

	iAssertObj(aAssertObj),

	iFileSize(0)

	{

	}

/** @internalComponent */

RResourceFileImpl::TExtra::~TExtra()

	{

	delete iBitArrayOfResourcesContainingCompressedUnicode;

	}

/** @internalComponent */

TBool RResourceFileImpl::TExtra::ContainsCompressedUnicodeL(TInt aRscIdx, TBool aFirstRscIsGen) const

	{

	if (aFirstRscIsGen)

		{

		// dictionary-compressed resource files can have an automatically generated 

		//resource which is the bit-array of resources containing compressed Unicode 

		//(this automatically generated resource does not have a corresponding bit 

		//for itself in the bit-array as it would be self-referring...)

		--aRscIdx; 

		if (aRscIdx<0)

			{

			//aRscIdx is referring to the automatically generated resource 

			//(which is the bit-array of resources containing compressed Unicode)

			return EFalse; 

			}

		}

	iAssertObj.AssertDebL(aRscIdx>=0, EBafPanicNegativeResourceIndex1);

	if (iBitArrayOfResourcesContainingCompressedUnicode==NULL)

		{

		return EFalse;

		}

	TInt index = aRscIdx / 8;

	iAssertObj.AssertDebL(index < iBitArrayOfResourcesContainingCompressedUnicode->Length(), EBafPanicBadIndex);

	return (*iBitArrayOfResourcesContainingCompressedUnicode)[index]&(1<<(aRscIdx%8));

	}

/** @internalComponent */

RResourceFileImpl::RResourceFileImpl() :

	iFile(NULL),

	iSizeOfLargestResourceWhenCompletelyUncompressed(0),

	iIndex(NULL),

	iOffset(0),

	iExtra(NULL),

	iFlagsAndNumberOfResources(0)

	{

	//Fixed class size - because of the BC reasons.

	//RResourceFileImpl size must be the same as RResourceFile size.

	enum

		{

		KRscFileImplSize = 24

		};

	COMPILE_TIME_ASSERT(sizeof(RResourceFileImpl)==KRscFileImplSize);

    // MSVC++ & GCCE can't handle this template instantiation

#if !defined(__VC32__) && !defined(__GCCE__) && !defined(__X86GCC__)

	//Fixed "iOffset" position - because of the BC reasons.

	COMPILE_TIME_ASSERT(_FOFF(RResourceFileImpl, iOffset)==12);

#endif

	}

/** Closes the resource file reader.

This function is called after finishing reading all resources.

@internalComponent */

void RResourceFileImpl::Close()

	{

	if ((iFile!=NULL) && ((iFlagsAndNumberOfResources & static_cast<TUint>(EFlagIsRomFile))==0 

		&& (iFlagsAndNumberOfResources & static_cast<TUint>(EFlagIsBufferRscFile))==0))

		{

		RFile* const file=STATIC_CAST(RFile*,iFile);

		file->Close();

		delete file;

		}

	//Here it indicates that it is reading from a HBufC8 rsc file buffer so we need to free the heap here

	if ((iFile!=NULL) && ((iFlagsAndNumberOfResources & static_cast<TUint>(EFlagIsBufferRscFile))!=0))

		{

		HBufC8* buffer=STATIC_CAST(HBufC8*,iFile);

		delete buffer;

		}

	iFile=NULL;

	iSizeOfLargestResourceWhenCompletelyUncompressed=0;

	delete iIndex;

	iIndex=NULL;

	if (iExtra)

		{

		delete [] iExtra->iDictionaryCompressionData.iCachedResourceBuffer;

		iExtra->iDictionaryCompressionData.iCachedResourceBuffer = NULL;

		delete [] iExtra->iDictionaryCompressionData.iCachedDictionaryIndex;

		iExtra->iDictionaryCompressionData.iCachedDictionaryIndex = 0;

		delete iExtra;

		iExtra=NULL;

		}

	iFlagsAndNumberOfResources=0;

	iOffset=0;

	}

/** Opens the resource file reader.

The resource file reader must be opened before reading resources or

checking the signature of the resource file. This function initially

closes the resource-file object if it is currently open. If a leave

occurs during the function, the object is reverted to its closed state.

@internalComponent

@param aFs Handle to a file server session.

@param aName File to open as a resource file.

@param aAssert Object which will be used to  determine panic/leave behaviour 

of the "L" methods.

@param aFileOffset The resource file section offset from the beginning of the file.

@param aFileSize The resource file section size.

@panic Some BAFL panic codes.

@leave KErrCorrupt The file is corrupted.

The method could panic or leave depending on the state of

iAssertObj member of RResourceFileImpl::TExtra class. */

void RResourceFileImpl::OpenL(RFs &aFs, const TDesC &aName, const TBaAssert& aAssert,

							  TUint aFileOffset/* = 0 */, TInt aFileSize/* = 0 */)

	{

	Close();

	CleanupClosePushL(*this);

	RFile* const file=new(ELeave) RFile;

	CleanupStack::PushL(TCleanupItem(CloseAndDeleteFile,file));

	User::LeaveIfError(file->Open(aFs, aName, EFileStream | EFileRead | EFileShareReadersOnly));

	iExtra=new (ELeave) TExtra(aAssert);

	const TBaAssert& assert_obj = iExtra->iAssertObj;

	iExtra->iFileOffset = aFileOffset;

	TInt fileSize = 0;

	if (aFileSize)

		{

		// With new format AIF, the RSC file is part of a larger file, so we need to set the

		// size of the RSC file here.

		fileSize = aFileSize;

		assert_obj.AssertDebL(fileSize > TInt(aFileOffset), EBafPanicBadOpenArg);

		}

	else

		{

		User::LeaveIfError(file->Size(fileSize));

		assert_obj.AssertDebL(fileSize > 0, EBafPanicFileSize2);

		}

	TUint8* romAddress=NULL;

	TInt seekRc(KErrNotSupported);

	// ESeekAddress in emulator will just get -5 and NULL romAddress.

	// On emulator there is also undesirable effect that after the call the ROM

	// resource file cannot be deleted while emulator is running. Seems base has

	// some kind of handle open on the rsc. One licensee has a use case to

	// re-compile resources while emulator is running. Hence Seek only in hw.

#ifndef __WINSCW__

	seekRc = file->Seek(ESeekAddress,REINTERPRET_CAST(TInt&,romAddress));

#endif

	if (romAddress==NULL || seekRc !=KErrNone)

		{

		iFile=file;

		// At the 1st line of this function we call Close() which sets

		// iFlagsAndNUmberOfResources to zero. Nothing between Close() and here changes

		// iFlagsAndNumberOfResources. So no need to assert EFlagIsRomFile is cleared.

//		assert_obj.AssertDebL((iFlagsAndNumberOfResources & static_cast<TUint>(EFlagIsRomFile))==0, 

//										EBafPanicBadInitialization1);

		CleanupStack::Pop(file);

		}

	else

		{

		iFile=CONST_CAST(TUint8*,romAddress);

		iFlagsAndNumberOfResources |= static_cast<TUint>(EFlagIsRomFile);

		CleanupStack::PopAndDestroy(file);

		}

	iExtra->iFileSize = fileSize;

	ReadHeaderAndResourceIndexL();

	CleanupStack::Pop(this);

	}

/** Opens the resource file reader.

The resource file reader must be opened before reading resources or

checking the signature of the resource file. This function initially

closes the resource-file object if it is currently open. If a leave

occurs during the function, the object is reverted to its closed state.

@internalComponent

@param aRscArchive buffer containing a full rsc file

@param aAssert Object which will be used to  determine panic/leave behaviour 

of the "L" methods.

@panic Some BAFL panic codes.

@leave KErrCorrupt The file is corrupted.

The method could panic or leave depending on the state of

iAssertObj member of RResourceFileImpl::TExtra class. */

void RResourceFileImpl::OpenL(const TDesC8& aRscArchive,const TBaAssert& aAssert)

	{

	Close();

	CleanupClosePushL(*this);

	iExtra=new (ELeave) TExtra(aAssert);

	//Since we are getting the entire buffer of the rsc file, we can treat

	//this equivalent to a ROM rsc file by pointing the iFile to

	//the start of the aRscArchive. We can depend directly on existing ReadL

	//to retrive the bytes directly from memory. No file open is required

	//and the handling of the rest of the rsc file is an exact copy of the

	//previous OpenL().A good way to reduce ROM size is to split the reading

	//part of the resource file into one separate function.//TODO

	//We also dont care about any fileOffset as the aRscArchive contains only

	//the buffer for one entire rsc file.

	//Get the length of the rsc file

	TInt fileSize=aRscArchive.Length();

	//iFile=STATIC_CAST(TAny*,(aRscArchive.AllocL())->Des()).Ptr());

	iFile = aRscArchive.AllocL();

	iExtra->iFileSize=fileSize;

	iFlagsAndNumberOfResources |= static_cast<TUint>(EFlagIsBufferRscFile);

	ReadHeaderAndResourceIndexL(); 

	CleanupStack::Pop(this);

	}

/** 

Retrieve the UID tuple of the opened resource file.

@internalComponent

@pre OpenL() has been called successfully.

@return The UIDs of the loaded resource file.

@panic BAFL 36 - data members are not initialized(probably - OpenL() hasn't been called). */

TUidType RResourceFileImpl::UidType() const

	{

	__ASSERT_ALWAYS(iExtra!=NULL,Panic(EBafPanicNotOpened));

	return iExtra->iUidType;

	}

/** Reads a resource specified by resource id into the specified descriptor.

The descriptor must be long enough to contain the entire resource. The

search for the resource uses the following algorithm: A resource id in

the range 1 to 4095 is looked up in this resource file. The function

leaves if there is no matching resource. If the resource id is greater

than 4095, then the most significant 20 bits of the resource id is

treated as an offset and the least significant 12 bits is treated as

the real resource id. If the offset matches the offset value defined

for this file, then the resource is looked up in this resource file

using the real resource id (i.e. the least significant 12 bits). If

the offset does not match, then the function leaves. Note, do not call

this function until a call to ConfirmSignatureL() has

completed successfully.

@internalComponent

@pre OpenL() is called.

@param aDes On return, contains the resource that has been read.

The function leaves if the descriptor is not long

enough to contain the entire resource.

@param aResourceId The numeric id of the resource to be read. The

function leaves if this resource id is not in this resource file.

@see ConfirmSignatureL()

@panic Some BAFL panic codes, if the file is corrupted.

@leave KErrCorrupt The file is corrupted. Some other error codes

are possible too.

The method could panic or leave depending on the state of

iAssertObj member of RResourceFileImpl::TExtra class. */

void RResourceFileImpl::ReadL(TDes8 &aDes,TInt aResourceId) const

	{

	HBufC8* const resource=AllocReadLC(aResourceId);

	aDes=*resource;

	CleanupStack::PopAndDestroy(resource);

	}

/** Reads a resource into a heap descriptor, returns a pointer to that

descriptor and pushes the pointer onto the cleanup stack.

A heap descriptor of appropriate length is allocated for the resource.

Ownership of the heap descriptor passes to the caller who must destroy

it and pop its pointer off the cleanup stack when it is no longer

needed.The search for the resource uses the following algorithm:A

resource id in the range 1 to 4095 is looked up in this resource file.

The function leaves if there is no matching resource.If the resource

id is greater than 4095, then the most significant 20 bits of the

resource id is treated as an offset and the least significant 12 bits

is treated as the real resource id. If the offset matches the offset

value defined for this file, then the resource is looked up in this

resource file using the real resource id (i.e. the least significant

12 bits). If the offset does not match, then the function leaves.Note,

do not call this function until a call to

ConfirmSignatureL() has completed successfully.

@internalComponent

@pre OpenL() is called.

@param aResourceId The numeric id of the resource to be read.

@return Pointer to a heap descriptor containing the resource.

@see ConfirmSignatureL()

@panic Some BAFL panic codes, if the file is corrupted.

@leave KErrCorrupt The file is corrupted.

@leave KErrNotFound There is no resource with aResourceId in the file.

Some other error codes are possible too.

The method could panic or leave depending on the state of

iAssertObj member of RResourceFileImpl::TExtra class. */

HBufC8* RResourceFileImpl::AllocReadLC(TInt aResourceId) const

	{

	if (!OwnsResourceIdL(aResourceId))

		{

		User::Leave(KErrNotFound);

		}

	const TBaAssert& assert_obj = iExtra->iAssertObj;

	//"-1" because the first resource has ID 0x*****001 (not 0x*****000)

	TInt resourceIndex=(aResourceId & EIdBits)-1; 

	if (iFlagsAndNumberOfResources & EFlagGenerate_RSS_SIGNATURE_ForFirstUserResource)

		{

		assert_obj.AssertDebL(iFlagsAndNumberOfResources & EFlagDictionaryCompressed, 

								EBafPanicBadFlags1);

		assert_obj.AssertDebL(iFlagsAndNumberOfResources & EFlagThirdUidIsOffset, 

								EBafPanicBadFlags2);

		if (resourceIndex>0)

			{

			--resourceIndex;

			}

		else

			{

			assert_obj.AssertDebL(resourceIndex==0, EBafPanicNegativeResourceIndex2);

			HBufC8* const resourceDataFor_RSS_SIGNATURE=HBufC8::NewMaxLC(8);

			TUint* wordPointer=REINTERPRET_CAST(TUint*,CONST_CAST(

											TUint8*,resourceDataFor_RSS_SIGNATURE->Ptr()));

			wordPointer[0]=4;

			wordPointer[1]=((iExtra->iUidType[2].iUid << 12) | 1);

			return resourceDataFor_RSS_SIGNATURE;

			}

		}

	const TBool firstResourceIsGenerated=

		(iFlagsAndNumberOfResources & 

		EFlagFirstResourceIsGeneratedBitArrayOfResourcesContainingCompressedUnicode);

	if (firstResourceIsGenerated)

		{

		assert_obj.AssertDebL(iFlagsAndNumberOfResources & 

								EFlagDictionaryCompressed, EBafPanicBadFlags6);

		//dictionary-compressed resource files can have an automatically generated 

		//resource which is the bit-array of resources containing compressed Unicode 

		//(this automatically generated resource does not have a corresponding bit for 

		//itself in the bit-array as it would be self-referring...)

		++resourceIndex; 

		}

	assert_obj.AssertDebL(resourceIndex>=0, EBafPanicNegativeResourceIndex3);

	HBufC8* const dictionaryDecompressedResourceData=DictionaryDecompressedResourceDataLC(

														resourceIndex,

														iFlagsAndNumberOfResources & static_cast<TUint>(EAllFlags),

														iExtra->iDictionaryCompressionData,

														*iIndex);

	if (!iExtra->ContainsCompressedUnicodeL(resourceIndex,firstResourceIsGenerated))

		{

		return dictionaryDecompressedResourceData;

		}

	HBufC8* const finalResourceData=DecompressUnicodeL(

										*dictionaryDecompressedResourceData,

										iSizeOfLargestResourceWhenCompletelyUncompressed);

	CleanupStack::PopAndDestroy(dictionaryDecompressedResourceData);

	CleanupStack::PushL(finalResourceData);

	return finalResourceData;

	}

/** @internalComponent

@return The first resource record.

@panic Some BAFL panic codes, if the file is corrupted.

@leave KErrCorrupt The file is corrupted.

Some other error codes are possible too.

The method could panic or leave depending on the state of

iAssertObj member of RResourceFileImpl::TExtra class. */

RResourceFileImpl::SSigRecord RResourceFileImpl::FirstRecordL() const

	{

	// Added to support reading of rel 6.x resource files.

	// rel 6.x files do not have signatures!

	HBufC8* const firstResource=AllocReadLC(1);

	// Basic check to test if the signature is of the correct size.

	if (firstResource->Size() != sizeof(SSigRecord))

		{

		User::Leave(KErrCorrupt);

		}

	SSigRecord sigRecord = *reinterpret_cast<const SSigRecord*>(firstResource->Ptr());

	CleanupStack::PopAndDestroy(firstResource);

	return sigRecord;

	}

/** Initialises the offset value from the first resource.

The function assumes that the first resource in the file consists of

two 32-bit integers. The first integer contains the version number and

the second is a self-referencing link whose value is the offset for

the resources in the file, plus 1.This function must be called before

calling Offset(), AllocReadL(), AllocReadLC() or ReadL().

@internalComponent

@pre OpenL() is called.

@param aSignature This argument value is not used by the function.

@see Offset()

@see AllocReadL()

@see AllocReadLC() 

@see ReadL()

@panic Some BAFL panic codes, if the file is corrupted.

@leave KErrCorrupt The file is corrupted.

Some other error codes are possible too.

The method could panic or leave depending on the state of

iAssertObj member of RResourceFileImpl::TExtra class. */

void RResourceFileImpl::ConfirmSignatureL(TInt /*aSignature*/)

    {

	SSigRecord first_record=FirstRecordL();

	// test removed by SC 29/09/98 - assume that existing resource layout and structures 

	//are fixed now

//	if (first_record.signature!=aSignature)

//		Leave(KErrBaflWrongResourceFileSignature);

    iOffset=first_record.offset & EOffsetBits;

    }

/** Initialises the offset value from the first resource.

The function tests to catch cases where the first resource is not an RSS_SIGNATURE.

It assumes that the first resource in the file consists of

two 32-bit integers. The first integer contains the version number and

the second is a self-referencing link whose value is the offset for

the resources in the file, plus 1.This function must be called before

calling Offset(), AllocReadL(), AllocReadLC() or ReadL().

@see Offset()

@see AllocReadL()

@see AllocReadLC() 

@see ReadL()

@internalComponent

@pre OpenL() is called.

@panic Some BAFL panic codes, if the file is corrupted.

@leave KErrCorrupt The file is corrupted.

Some other error codes are possible too.

The method could panic or leave depending on the state of

iAssertObj member of RResourceFileImpl::TExtra class. */

void RResourceFileImpl::ConfirmSignatureL()

	{

	// Added to support reading of rel 6.x resource files.

	SSigRecord firstRecord=FirstRecordL();

	// If the resource offset does not correspond to the first resource

	// this is not a resource signature.