diff -r 5cc91383ab1e -r 7333d7932ef7 secureswitools/swisistools/source/rscparser/barsreadimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/secureswitools/swisistools/source/rscparser/barsreadimpl.cpp Tue Aug 31 15:21:33 2010 +0300 @@ -0,0 +1,438 @@ +// 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: +// Resource reader +// +// +/** +* @file BaRsReadImpl.cpp +* +* @internalComponent +* @released +*/ +#include +#include +#include +#include "barsreadimpl.h" +#include "barsc2.h" + +#define REINTERPRET_CAST(type,exp) (reinterpret_cast(exp)) + +/** @internalComponent +An error will be issued at compile time if the class size is not KRsReaderImplSize. */ +TResourceReaderImpl::TResourceReaderImpl() : + iBuffer(NULL), + iCurrentPtr(NULL) + { + //TResourceReaderImpl size. It should be 8 because of the BC reasons. + //8 is the size of TResourceReader class. + enum + { + KRsReaderImplSize = 8 + }; + assert(sizeof(TResourceReaderImpl) == KRsReaderImplSize); + } + +/** Sets the buffer containing the resource data. + +The current position within the buffer is set to the start of the buffer so +that subsequent calls to the interpreting functions, for example ReadInt8(), +start at the beginning of this buffer. + +@internalComponent +@param aBuffer Pointer to an 8 bit non-modifiable buffer containing +or representing resource data. +@param aResourceId The numeric id of the resource to be read. +@post Buffer pointer is initialized. +@post Buffer current position pointer is initialized. */ +void TResourceReaderImpl::SetBuffer(const Ptr8* aBuffer) +{ + iBuffer=aBuffer; + iCurrentPtr= (TUint8*)iBuffer->GetPtr(); +} + +/** Sets the buffer and current position to NULL. +@internalComponent +@post Buffer pointer is set to NULL. +@post Buffer current position pointer is set to NULL. */ +void TResourceReaderImpl::ResetBuffer() + { + iBuffer=NULL; + iCurrentPtr=NULL; + } + +/** Returns the current position within the resource buffer. + +The function makes no assumption about the type of data in the buffer at the +current position. + +@internalComponent +@return A pointer to the current position within the resource buffer. */ +const TAny* TResourceReaderImpl::Ptr() + { + return(iCurrentPtr); + } + +/** Updates iCurrentPtr with a new value. + +@internalComponent +@pre iBuffer is not NULL. +@pre aPtr is not NULL. +@param aPtr The new value of iCurrentPtr. +@post iCurrentPtr is updated. +@leave KErrOff The new iCurrentPtr points beyond the buffer end. */ +void TResourceReaderImpl::MovePtrL(const TUint8* aPtr) + { + assert(iBuffer != NULL); + assert(aPtr != NULL); + if(aPtr > ((TUint8*)( iBuffer->GetPtr() + iBuffer->GetLength() ))) + { + std::string errMsg= "Failed : Trying to access pointer beyond valid range for registrationFile"; + throw CResourceFileException(errMsg); + } + + iCurrentPtr=aPtr; + } + +/** Interprets the data at the current buffer position as leading byte count data +and constructs a 16 bit heap buffer containing a copy of this data. + +The data is interpreted as: + +a byte value defining the number of 16 bit text characters +(the resource string/binary data length is limited to 255 characters max) + +followed by: + +the 16 bit text characters. + +If the value of the leading byte is zero, the function assumes that no data +follows the leading byte and returns a NULL pointer. + +The current position within the resource buffer is updated. + +Do not use this explicit 16 bit variant when the resource contains binary +data; use the explicit 8 bit variant instead. If the resource contains text, +use the build independent variant ReadHBufCL(). + +@internalComponent +@pre The same as for ReadTPtrC16L(). +@return Pointer to the 16bit heap buffer containing a +copy of the data following the leading byte count at +the current position within the resource buffer. The +pointer can be NULL. +@post iCurrentPtr is updated. +@leave The same as ReadTPtrC16L(). +@see ReadTPtrC16L() */ + +Ptr16* TResourceReaderImpl::ReadHBufCL() + { + + PtrC16* ucode = ReadTPtrC16L(); + if(NULL==ucode) + return NULL; + Ptr16* unicode = new Ptr16(ucode->iMaxLength); + memcpy(unicode->GetPtr(),ucode->iPtr,ucode->iMaxLength*2); + unicode->UpdateLength(ucode->iMaxLength); + return unicode; + } + + +/** Interprets the data at the current buffer position as leading byte count data +and constructs an 8 bit non modifiable pointer to represent this data. + +The data is interpreted as: + +a byte value defining the number of text characters or the length of binary +data (the resource string/binary data length is limited to 255 characters max) + +followed by: + +the 8 bit text characters or binary data. + +If the value of the leading byte is zero, calling Length() on the returned +TPtrC8 returns zero. + +The current position within the resource buffer is updated. + +Use this explicit 8 bit variant when the resource contains binary data. If +the resource contains text, then use the build independent variant ReadTPtrC(). + +In general, this type of resource data corresponds to one of the following: + +a LTEXT type in a resource STRUCT declaration. + +a variable length array within a STRUCT declaration which includes the LEN +BYTE keywords. + +@internalComponent +@pre iCurrentPtr != NULL. +@pre The same as MovePtrL(const TUint8* aPtr). +@return 8bit non modifiable pointer representing +the data following the leading byte count at the +current position within the resource buffer. +@post iCurrentPtr is updated. +@leave The same as MovePtrL(const TUint8* aPtr). +@see MovePtrL(const TUint8* aPtr) */ +PtrC8* TResourceReaderImpl::ReadTPtrC8L() + { + assert(iCurrentPtr != NULL); + const TUint8* currentPtr=iCurrentPtr;//TUint8 pointer is used, which means that the + //resource string length is limited to 255 characters max. + const TInt strLen=*currentPtr; + ++currentPtr; + + PtrC8* unicode = new PtrC8; + + if(!strLen) + unicode = NULL; + else + { + unicode ->iMaxLength = strLen; + unicode ->iPtr = currentPtr; + } + MovePtrL(currentPtr+strLen); + return unicode; + } + +/** Interprets the data at the current buffer position as leading byte count data +and constructs a 16 bit non modifiable pointer to represent this data. + +The data is interpreted as: + +a byte value defining the number of 16 bit text characters +(the resource string/binary data length is limited to 255 characters max) + +followed by: + +the 16 bit text characters. + +If the value of the leading byte is zero, calling Length() on the returned +TPtrC16 returns zero. + +The current position within the resource buffer is updated. + +Do not use this explicit 16 bit variant when the resource contains binary +data; use the explicit 8 bit variant instead. If the resource contains text, +use the build independent variant ReadTPtrC(). + +@internalComponent +@pre iCurrentPtr != NULL. +@pre The same as MovePtrL(const TUint8* aPtr). +@return Pointer to an 8bit variant flat array. +@post iCurrentPtr is updated. +@leave KErrCorrupt The resource is a unicode string and it is not properly aligned. +@leave The same as MovePtrL(const TUint8* aPtr). +@see MovePtrL(const TUint8* aPtr) */ + +PtrC16* TResourceReaderImpl::ReadTPtrC16L() + { + assert(iCurrentPtr != NULL); + const TUint8* currentPtr=iCurrentPtr;//TUint8 pointer is used, which means that the + + //resource string length is limited to 255 characters max. + const TInt unicodeLength=*currentPtr; + ++currentPtr; + if (unicodeLength!=0) + { + if (REINTERPRET_CAST(TUint,currentPtr)&0x1) + { + // The resource compiler puts out a padding byte (arbitrarily 0xab) + // to ensure the alignment of Unicode strings within each resource. + if(*currentPtr!=0xab) + { + std::string errMsg= "Failed : Improper alignment of Unicode strings (0xab) within each resource."; + throw CResourceFileException(errMsg); + } + ++currentPtr; + } + } + + if (unicodeLength ==0) + { + MovePtrL(currentPtr); + return NULL; + } + else + { + PtrC16* unicode = new PtrC16; + unicode ->iMaxLength = unicodeLength; + unicode ->iPtr = (TUint16*) currentPtr; + + currentPtr+=unicodeLength*sizeof(TText16); + MovePtrL(currentPtr); + return unicode; + } +} + + +/** Interprets the data at the current buffer position as a TInt8 type and returns +the value as a TInt. + +The current position within the resource buffer is updated. + +In general, a TInt8 corresponds to a BYTE type in a resource STRUCT declaration. + +Note that in Symbian OS, a TInt is at least as big as a TInt8. + +@internalComponent +@pre iCurrentPtr != NULL. +@pre The same as MovePtrL(const TUint8* aPtr). +@return The TInt8 value taken from the resource buffer. +@post The same as MovePtrL(const TUint8* aPtr). +@leave The same as MovePtrL(const TUint8* aPtr). +@see MovePtrL(const TUint8* aPtr) */ +TInt TResourceReaderImpl::ReadInt8L() + { + assert(iCurrentPtr != NULL); + const TUint8* currentPtr=iCurrentPtr; + MovePtrL(currentPtr+sizeof(TInt8)); + return(*(TInt8*)currentPtr); + } + +/** Interprets the data at the current buffer position as a TUint8 type and returns +the value as a TUint. + +The current position within the resource buffer is updated. + +In general, a TUint8 corresponds to a BYTE type in a resource STRUCT declaration. + +Note that in Symbian OS, a TUint is at least as big as a TUint8. + +@internalComponent +@pre iCurrentPtr != NULL. +@pre The same as MovePtrL(const TUint8* aPtr). +@return The TUint8 value taken from the resource buffer. +@post The same as MovePtrL(const TUint8* aPtr). +@leave The same as MovePtrL(const TUint8* aPtr). +@see MovePtrL(const TUint8* aPtr) */ +TUint32 TResourceReaderImpl::ReadUint8L() + { + assert(iCurrentPtr != NULL); + const TUint8* currentPtr=iCurrentPtr; + MovePtrL(currentPtr+sizeof(TUint8)); + return(*(TUint8*)currentPtr); + } + +/** Interprets the data at the current buffer position as a TInt16 type and returns +the value as a TInt. + +The current position within the resource buffer is updated. + +In general, a TInt16 corresponds to a WORD type in a resource STRUCT declaration. + +Note that in Symbian OS, a TInt is at least as big as a TInt16. + +@internalComponent +@pre iCurrentPtr != NULL. +@pre The same as MovePtrL(const TUint8* aPtr). +@return The TInt16 value taken from the resource buffer. +@post The same as MovePtrL(const TUint8* aPtr). +@leave The same as MovePtrL(const TUint8* aPtr). +@see MovePtrL(const TUint8* aPtr) */ +TInt TResourceReaderImpl::ReadInt16L() + { + assert(iCurrentPtr != NULL); + if (((TUint32)iCurrentPtr)%2) + { + TInt16 ret; + ReadL(&ret,sizeof(ret)); + return(ret); + } + const TUint8* currentPtr=iCurrentPtr; + MovePtrL(currentPtr+sizeof(TInt16)); + return(*(TInt16*)currentPtr); + } + +/** Interprets the data at the current buffer position as a TInt32 type and returns +the value as a TInt. + +The current position within the resource buffer is updated. + +In general, a TInt32 corresponds to a LONG type in a resource STRUCT declaration. + +Note that in Symbian OS, TInt and TInt32 are the same size. + +@internalComponent +@pre iCurrentPtr != NULL. +@pre The same as MovePtrL(const TUint8* aPtr). +@return The TInt32 value taken from the resource buffer. +@post The same as MovePtrL(const TUint8* aPtr). +@leave The same as MovePtrL(const TUint8* aPtr). +@see MovePtrL(const TUint8* aPtr) */ +TInt TResourceReaderImpl::ReadInt32L() + { + assert(iCurrentPtr != NULL); + if (((TUint)iCurrentPtr)%4) + { + TInt32 ret; + ReadL(&ret,sizeof(ret)); + return(ret); + } + const TUint8* currentPtr=iCurrentPtr; + MovePtrL(currentPtr+sizeof(TInt32)); + return(*(TInt32*)currentPtr); + } + + +/** Interprets the data at the current buffer position as a TUint32 type and returns +the value as a TUint. + +The current position within the resource buffer is updated. + +In general, a TUint32 corresponds to a LONG type in a resource STRUCT declaration. + +Note that in Symbian OS a TUint is the same size as a TUint32. + +@internalComponent +@pre iCurrentPtr != NULL. +@pre The same as MovePtrL(const TUint8* aPtr). +@return The TUint32 value taken from the resource buffer. +@post The same as MovePtrL(const TUint8* aPtr). +@leave The same as MovePtrL(const TUint8* aPtr). +@see MovePtrL(const TUint8* aPtr) */ +TUint32 TResourceReaderImpl::ReadUint32L() + { + assert(iCurrentPtr != NULL); + if (((TUint32)iCurrentPtr)%4) + { + TUint32 ret; + ReadL(&ret,sizeof(ret)); + return(ret); + } + const TUint8* currentPtr=iCurrentPtr; + MovePtrL(currentPtr+sizeof(TUint32)); + return(*(TUint32*)currentPtr); + } + +/** Copies a specified length of data from the resource buffer, starting at the +current position within the buffer, into the location pointed to by a specified +pointer. No assumption is made about the type of data at being read. + +The current position within the resource buffer is updated. + +@internalComponent +@pre iCurrentPtr != NULL. +@pre The same as MovePtrL(const TUint8* aPtr). +@param aPtr Pointer to the target location for data copied from the resource buffer. +@param aLength The length of data to be copied from the resource buffer. +@post The same as MovePtrL(const TUint8* aPtr). +@leave The same as MovePtrL(const TUint8* aPtr). +@see MovePtrL(const TUint8* aPtr) */ +void TResourceReaderImpl::ReadL(TAny* aPtr,TInt aLength) + { + assert(iCurrentPtr != NULL); + const TUint8* currentPtr=iCurrentPtr; + MovePtrL(currentPtr+aLength); + memcpy(aPtr,currentPtr,aLength); + } \ No newline at end of file