// Copyright (c) 2009 - 2010 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:

//

/** 

* @file BaRscImpl.cpp

*

* @internalComponent

* @released

*/

#include <iostream>

#include <fstream>

#include <cassert>

#include <sys/stat.h>

#include <sstream>

#include "barsc2.h"

#include "barscimpl.h"

#include "dictionarycompression.h"

#include "ucmp.h"

#include "util.h"

#include "parse.h"

#define REINTERPRET_CAST(type,exp) (reinterpret_cast<type>(exp))

#define CONST_CAST(type,exp) (const_cast<type>(exp))

#define STATIC_CAST(type,exp) (static_cast<type>(exp))

inline TUint8* MemCopy(TAny* aTrg, const TAny* aSrc, TInt aLength)

{ return (TUint8*)memmove(aTrg, aSrc, aLength) + aLength; }

/** Cleanup function.

@internalComponent

@param aArrayOfDictionaryCompressionBitStreams Pointer to an vector of 

RDictionaryCompressionBitStream objects which have to be closed. */

void CloseArrayOfDictionaryCompressionBitStreams(TAny* aArray)

{

	typedef std::vector<RDictionaryCompressionBitStream> RDictComprBitStream;

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

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

		{

		array[i].clear();

		}

	array->clear();

}

RResourceFileImpl::TExtra::TExtra():

	iBitArrayOfResourcesContainingCompressedUnicode(NULL),

	iFileOffset(0),

	iFileSize(0)

{

}

RResourceFileImpl::TExtra::~TExtra()

{

	delete [] iDictionaryCompressionData.iCachedResourceBuffer;

	iDictionaryCompressionData.iCachedResourceBuffer = NULL;

	delete [] iDictionaryCompressionData.iCachedDictionaryIndex;

	iDictionaryCompressionData.iCachedDictionaryIndex = 0;

	delete iBitArrayOfResourcesContainingCompressedUnicode;

}

TInt32 RResourceFileImpl::TExtra::ContainsCompressedUnicode(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; 

			}

	}

	assert(aRscIdx>=0);

	if (iBitArrayOfResourcesContainingCompressedUnicode==NULL)

		{

		return EFalse;

		}

	TInt index = aRscIdx/8;

	assert(index < iBitArrayOfResourcesContainingCompressedUnicode->GetLength());

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

}

RResourceFileImpl::RResourceFileImpl() :

	iResourceContents(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 CResourceFile size.

	enum

		{

		KRscFileImplSize = 24

		};	

	assert(sizeof(RResourceFileImpl) == KRscFileImplSize);

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

	assert(offsetof(RResourceFileImpl, iOffset)==12);

}

RResourceFileImpl::~RResourceFileImpl()

{

	if(iResourceContents)

	{

		if (iResourceContents->is_open())

		{

			iResourceContents->close();

		}

		delete iResourceContents;

	}

	iSizeOfLargestResourceWhenCompletelyUncompressed=0;

	delete iIndex;

	iIndex=NULL;

	if (iExtra)

	{

		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. 

@internalComponent

@param aName File to open as a resource file.

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

@param aFileSize The resource file section size.

@leave - The file is corrupted.

*/

void RResourceFileImpl::OpenL(

						  const std::string& aName, 

						  TUint32 aFileOffset, 

						  TInt aFileSize)

{

	iResourceContents= new std::ifstream(aName.c_str(), std::ios::in|std::ios::binary);

	if(!iResourceContents->good())

	{

		std::string errMsg= "Unable to open RSC file. " + aName;

		if (iResourceContents->is_open())

			iResourceContents->close();

		if(iResourceContents)

			delete iResourceContents;

		throw CResourceFileException(errMsg);

	}

	iExtra=new TExtra();

	iExtra->iFileOffset = aFileOffset;

	TInt fileSize = 0;

	if (aFileSize)

		{

		fileSize = aFileSize;

		assert(fileSize > TInt(aFileOffset));

		}

	else

		{

		// Get the resource file size

		struct stat resourceFileStats;

		if (stat(aName.c_str(),&resourceFileStats) == 0)

			{

			// The size of the file in bytes is in

			// resourceFileStats.st_size

			fileSize=resourceFileStats.st_size;

			assert(fileSize > 0);

			}   	

		else

			{

			if (iResourceContents->is_open())

					iResourceContents->close();		

			std::string errMsg="Invalid RSC File";

			throw CResourceFileException(errMsg);

			}		

		}

	iExtra->iFileSize = fileSize;	

	// Verify the header of the RSC and get the resource index

	ReadHeaderAndResourceIndexL();

}

/** 

Retrieve the UID tuple of the opened resource file.

@internalComponent

@pre OpenL() has been called successfully.

@return The UIDs of the loaded resource file.

*/

TUidType RResourceFileImpl::UidType() const

{

	assert(iExtra!=NULL);

	return iExtra->iUidType;

}

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

buffer.

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

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

it. 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 buffer containing the resource.

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

@leave - The file is corrupted.

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

*/

Ptr8* RResourceFileImpl::AllocReadL(const TInt& aResourceId) 

{

	// Check if the resource id is present in the RSC file

	if (!OwnsResourceId(aResourceId))

	{

		std::ostringstream errDispStream;

		errDispStream<<"Resource ID:";

		errDispStream<<aResourceId;

		errDispStream<<" is not present in the RSC file";

		throw CResourceFileException(errDispStream.str());

	}

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

	TInt resourceIndex= (aResourceId & EIdBits)-1; 

	if (iFlagsAndNumberOfResources & EFlagGenerate_RSS_SIGNATURE_ForFirstUserResource)

	{

		assert(iFlagsAndNumberOfResources & EFlagDictionaryCompressed);

		assert(iFlagsAndNumberOfResources & EFlagThirdUidIsOffset);

		if (resourceIndex>0)

		{

			--resourceIndex;

		}

		else

		{

			assert(resourceIndex==0);

			Ptr8* resourceDataFor_RSS_SIGNATURE = new Ptr8(8);

			if(NULL==resourceDataFor_RSS_SIGNATURE || NULL==resourceDataFor_RSS_SIGNATURE->GetPtr())

			{

				std::string errMsg= "Failed : Error in Reading File. Memory Allocation Failed";

				throw CResourceFileException(errMsg);

			}

			resourceDataFor_RSS_SIGNATURE->SetLength(8);

			TUint* wordPointer=REINTERPRET_CAST(TUint*,CONST_CAST(TUint8*,resourceDataFor_RSS_SIGNATURE->GetPtr()));

			wordPointer[0]=4;

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

			return resourceDataFor_RSS_SIGNATURE;

		}

	}

	const TBool firstResourceIsGenerated=

		(iFlagsAndNumberOfResources & 

		EFlagFirstResourceIsGeneratedBitArrayOfResourcesContainingCompressedUnicode);

	if (firstResourceIsGenerated)

	{

		assert(iFlagsAndNumberOfResources & EFlagDictionaryCompressed);

		//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(resourceIndex>=0);

	Ptr8* const dictionaryDecompressedResourceData = DictionaryDecompressedResourceDataL(resourceIndex,

						iFlagsAndNumberOfResources & static_cast<TUint>(EAllFlags),	

						iExtra->iDictionaryCompressionData,	

						iIndex);

	// Return the resource data if its not unicode compressed.

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

	{

		return dictionaryDecompressedResourceData;

	}

	Ptr8* const finalResourceData=DecompressUnicodeL(dictionaryDecompressedResourceData);

	delete dictionaryDecompressedResourceData;

	return finalResourceData;

}

/** The method will decompress the unicode data (aInputResourceData argument), allocate enough

memory from the heap for the decompressed data, copy the data there and return a buffer

to the decompressed data.

The method doesn't own the allocated heap memory for the decompressed data. It's a caller

responsibility to deallocate the allocated memory.

@internalComponent

@param aInputResourceData Compressed data.

@pre OpenL() is called.

@leave - The file is corrupted.

@leave - There is not enough memory for the decompressed data.

*/

Ptr8* RResourceFileImpl::DecompressUnicodeL(const Ptr8* aInputResourceData) const

{

	const TInt numberOfBytesInInput= aInputResourceData->GetLength();

	assert(iSizeOfLargestResourceWhenCompletelyUncompressed>0);

	Ptr8* outputResourceData= new Ptr8(iSizeOfLargestResourceWhenCompletelyUncompressed);

	if(NULL==outputResourceData || NULL==outputResourceData->GetPtr())

	{

		std::string errMsg= "Failed : Error in Reading File. Memory Allocation Failed";

		throw CResourceFileException(errMsg);

	}

	const TUint8* input= aInputResourceData->GetPtr();

	TInt index=0;

	TBool decompressRun=ETrue;

	while (1)

	{

		assert(index<numberOfBytesInInput);

		TInt runLength=input[index];

		// The run-length occupies a single byte if it is less than 128, 

		// otherwise it occupies two bytes (in little-endian byte order), 

		// with the most significant bit of the first byte set to non-zero 

		//to indicate that the run-length occupies two bytes.

		if (runLength & 0x80)

		{

			++index;

			if (index>=numberOfBytesInInput)

			{

				std::string errMsg="Invalid Rsc File";

				throw CResourceFileException(errMsg);

			}

			runLength &= ~0x80;

			runLength <<= 8;

			runLength |= input[index];

		}

		++index;

		if (runLength>0)

		{			

			if (decompressRun)

			{

				AppendDecompressedUnicodeL(

										outputResourceData,				

										const_cast<unsigned char *>(input+index),

										runLength);

			}

			else

			{

				assert(

					(outputResourceData->GetLength() + runLength) <= 

					iSizeOfLargestResourceWhenCompletelyUncompressed);

				memcpy((char*)(outputResourceData->GetPtr()+outputResourceData->GetLength()),(char*)(input+index),runLength);				

				outputResourceData->UpdateLength(runLength);

			}

			index+=runLength;

		}

		if (index>numberOfBytesInInput)

		{

			std::string errMsg="Invalid Rsc File";

			throw CResourceFileException(errMsg);

		}

		if (index>=numberOfBytesInInput)

		{

			break;

		}

			decompressRun=!decompressRun;

	}	

	return outputResourceData;

}

/** @internalComponent

@return The first resource record.

@leave - The file is corrupted.

*/

RResourceFileImpl::SSigRecord RResourceFileImpl::FirstRecordL() const

{

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

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

	Ptr8* const firstResource=AllocReadL(1);

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

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

	{

		std::string errMsg="Invalid RSS Signature";

		throw CResourceFileException(errMsg);

	}

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

	delete firstResource;

	return sigRecord;

}

/** 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() or ReadL().

@internalComponent

@pre OpenL() is called.

@leave if the file is corrupted.

Some other error codes are possible too.

*/

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.

	if ((firstRecord.offset & EIdBits) != 1)

	{

		std::string errMsg="Failed : Invalid RSS Signature";

		throw CResourceFileException(errMsg);

	}

	iOffset=(firstRecord.offset & EOffsetBits);

}

/** The method will decomress the unicode data (aCompressedUnicode argument) and append

the decompressed data to the end of aBuffer (aBuffer argument).

@internalComponent

@pre OpenL() is called.

@param aBuffer Destination buffer.

@param aCompressedUnicode Compressed unicode buffer.

@leave - The file is corrupted.

*/

void RResourceFileImpl::AppendDecompressedUnicodeL(

												   Ptr8* aBuffer,

												   const TUint8*  aCompressedUnicode,

												   const TInt& aLengthOfCompressedUnicode) const

{

	if (aLengthOfCompressedUnicode>0)

	{

		TUint8* startOfDecompressedUnicode= aBuffer->GetPtr() + aBuffer->GetLength();

		if (reinterpret_cast<TUint32>(startOfDecompressedUnicode) & 0x01)

		{			

			TUint8 padChar = 0xab;

			memcpy(startOfDecompressedUnicode,&padChar,1);

			++startOfDecompressedUnicode;

			aBuffer->UpdateLength(1);

		}

		const TInt maximumOutputLength= (

			iSizeOfLargestResourceWhenCompletelyUncompressed - (aBuffer->GetLength()))/2; 

		TMemoryUnicodeSink decompressedUnicode(reinterpret_cast<TUint16*>(startOfDecompressedUnicode));

		TInt lengthOfDecompressedUnicode;

		TInt numberOfInputBytesConsumed;

		TUnicodeExpander unicodeExpander;

		unicodeExpander.ExpandL(decompressedUnicode,

								aCompressedUnicode,

								maximumOutputLength,

								aLengthOfCompressedUnicode,

								&lengthOfDecompressedUnicode,

								&numberOfInputBytesConsumed);

		TInt temp;

		unicodeExpander.FlushL(decompressedUnicode,maximumOutputLength,temp);

		lengthOfDecompressedUnicode+=temp;

		aBuffer->UpdateLength(lengthOfDecompressedUnicode*2);

		assert(numberOfInputBytesConsumed == aLengthOfCompressedUnicode);		

	}

}

/** Tests whether the resource file owns the specified resource id.

The resource file owns the resource id if the most significant 20 bits

of the resource id are zero or match the offset value as returned from

a call to the Offset() member function or if the resource id is not out of range.

@internalComponent

@pre OpenL() is called.

@param aResourceId The resource id to test.

@return True, if the resource file owns the id, false otherwise.